corregit makefile de macos

corregit makefile de windows
corregit makefile de tools/pack_resources
2025-12-23 10:36:03 +01:00 · 2025-12-23 10:03:32 +01:00 · 2025-12-23 08:52:47 +01:00 · 2025-12-23 08:18:13 +01:00 · 2025-12-23 07:41:42 +01:00 · 2025-12-19 17:26:20 +01:00
75 changed files with 2046 additions and 1240 deletions
--- a/.clang-tidy
+++ b/.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/.*' }
--- a/.claude/settings.local.json
+++ b/.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": []
+  }
+}
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,7 +1,7 @@
 # CMakeLists.txt

 cmake_minimum_required(VERSION 3.10)
-project(orni VERSION 0.7.0)
+project(orni VERSION 0.7.1)

 # Info del proyecto
 set(PROJECT_LONG_NAME "Orni Attack")
@@ -84,6 +84,12 @@ endif()
 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)
@@ -99,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)
@@ -127,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()
--- a/117
+++ b/117
@@ -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] }")
-    LONG_NAME      := $(shell powershell -Command "$$line = Get-Content CMakeLists.txt | Where-Object {$$_ -match 'PROJECT_LONG_NAME'}; if ($$line -match '\"(.+)\"') { $$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 "(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
-RAW_VERSION := $(shell echo $(VERSION) | sed 's/^v//')
+# ==============================================================================
+# 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,14 +51,16 @@ endif
 # ==============================================================================
 # PLATFORM-SPECIFIC UTILITIES
 # ==============================================================================
+# Use Unix commands always (MinGW Make uses bash even on Windows)
+RMFILE          := rm -f
+RMDIR           := rm -rf
+MKDIR           := mkdir -p
+
 ifeq ($(OS),Windows_NT)
-    RMFILE          := del /Q
-    RMDIR           := rmdir /S /Q
-    MKDIR           := mkdir
+    # Windows-specific: Force cmd.exe shell for PowerShell commands
+    SHELL := cmd.exe
 else
-    RMFILE          := rm -f
-    RMDIR           := rm -rf
-    MKDIR           := mkdir -p
+    # Unix-specific
    UNAME_S         := $(shell uname -s)
 endif

@@ -71,7 +77,7 @@ PACK_TOOL := tools/pack_resources/pack_resources
 .PHONY: pack_tool resources.pack

 pack_tool:
-	@$(MAKE) -C tools/pack_resources
+	@make -C tools/pack_resources

 resources.pack: pack_tool
 	@echo "Creating resources.pack..."
@@ -145,12 +151,18 @@ macos_release: pack_tool resources.pack
 	@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
-	@echo "Updating Info.plist with version $(RAW_VERSION)..."
+	# Update Info.plist version and names
+	@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
@@ -183,8 +195,9 @@ macos_release: pack_tool resources.pack

 # 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)"
@@ -194,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"

@@ -213,37 +226,25 @@ linux_release:

 # Windows Release (requires MinGW on Windows or cross-compiler on Linux)
 .PHONY: windows_release
-windows_release:
-	@echo "Creating Windows release - Version: $(VERSION)"
-	@echo "Note: This target should be run on Windows with MinGW or use windows_cross on Linux"
-
-	# Clean previous
-	@$(RMDIR) "$(RELEASE_FOLDER)"
-	@$(RMFILE) "$(WINDOWS_RELEASE)"
-
-	# Create folder
-	@$(MKDIR) "$(RELEASE_FOLDER)"
-
-	# Copy resources
-	@cp -r resources "$(RELEASE_FOLDER)/"
-	@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
+windows_release: pack_tool resources.pack
+	@echo off
+	@echo Creating Windows release - Version: $(VERSION)
+	@powershell if (Test-Path "$(RELEASE_FOLDER)") {Remove-Item "$(RELEASE_FOLDER)" -Recurse -Force}
+	@powershell if (Test-Path "$(WINDOWS_RELEASE)") {Remove-Item "$(WINDOWS_RELEASE)"}
+	@powershell if (-not (Test-Path "$(RELEASE_FOLDER)")) {New-Item "$(RELEASE_FOLDER)" -ItemType Directory}
+	@powershell Copy-Item -Path "resources.pack" -Destination "$(RELEASE_FOLDER)"
+	@powershell Copy-Item "release\dll\SDL3.dll" -Destination "$(RELEASE_FOLDER)"
+	@powershell Copy-Item "release\dll\libwinpthread-1.dll" -Destination "$(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)"}
+	@windres release/$(TARGET_NAME).rc -O coff -o release/$(TARGET_NAME).res 2>nul || echo Warning: windres failed
+	@cmake -B build -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Release
 	@cmake --build build
-	@cp $(TARGET_FILE).exe "$(RELEASE_FILE).exe" || cp $(TARGET_FILE) "$(RELEASE_FILE).exe"
-
-	# Package
-	@cd "$(RELEASE_FOLDER)" && zip -r ../$(WINDOWS_RELEASE) *
-	@echo "✓ Windows release created: $(WINDOWS_RELEASE)"
-
-	# Cleanup
-	@$(RMDIR) "$(RELEASE_FOLDER)"
+	@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
+	@powershell Compress-Archive -Path "$(RELEASE_FOLDER)\*" -DestinationPath "$(WINDOWS_RELEASE)" -Force
+	@echo Release created: $(WINDOWS_RELEASE)
+	@powershell if (Test-Path "$(RELEASE_FOLDER)") {Remove-Item "$(RELEASE_FOLDER)" -Recurse -Force}

 # Raspberry Pi Release (cross-compilation from Linux/macOS)
 .PHONY: rpi_release
@@ -262,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"

@@ -298,8 +299,8 @@ windows_cross:
 	@$(MKDIR) "$(RELEASE_FOLDER)"

 	# Copy resources
-	@cp -r resources "$(RELEASE_FOLDER)/"
-	@cp release/dll/*.dll "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: DLLs not found in release/dll/"
+	@cp resources.pack "$(RELEASE_FOLDER)/"
+	@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"

@@ -335,7 +336,7 @@ else
 	@$(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
+	@make -C tools/pack_resources clean 2>/dev/null || true
 endif
 	@echo "Clean complete"

--- a/release/orni.res
+++ b/release/orni.res
--- a/source/core/audio/.clang-tidy
+++ b/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: '-*'
--- a/source/core/audio/jail_audio.hpp
+++ b/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) {
--- a/source/core/defaults.hpp
+++ b/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 MIN_ZOOM = 0.5f;        // 320x240 minimum
-constexpr float ZOOM_INCREMENT = 0.1f;  // 10% steps (F1/F2)
+constexpr float BASE_ZOOM = 1.0F;       // 640x480 baseline
+constexpr float MIN_ZOOM = 0.5F;        // 320x240 minimum
+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)
@@ -28,12 +31,12 @@ namespace Zones {
 // Totes les zones definides com a percentatges de Game::WIDTH (640) i Game::HEIGHT (480)

 // Percentatges d'alçada (divisió vertical)
-constexpr float SCOREBOARD_TOP_HEIGHT_PERCENT = 0.02f;     // 10% superior
-constexpr float MAIN_PLAYAREA_HEIGHT_PERCENT = 0.88f;      // 80% central
-constexpr float SCOREBOARD_BOTTOM_HEIGHT_PERCENT = 0.10f;  // 10% inferior
+constexpr float SCOREBOARD_TOP_HEIGHT_PERCENT = 0.02F;     // 10% superior
+constexpr float MAIN_PLAYAREA_HEIGHT_PERCENT = 0.88F;      // 80% central
+constexpr float SCOREBOARD_BOTTOM_HEIGHT_PERCENT = 0.10F;  // 10% inferior

 // Padding horizontal per a PLAYAREA (dins de MAIN_PLAYAREA)
-constexpr float PLAYAREA_PADDING_HORIZONTAL_PERCENT = 0.015f;  // 5% a cada costat
+constexpr float PLAYAREA_PADDING_HORIZONTAL_PERCENT = 0.015F;  // 5% a cada costat

 // --- CÀLCULS AUTOMÀTICS DE PÍXELS ---
 // Càlculs automàtics a partir dels percentatges
@@ -44,7 +47,7 @@ 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 SCOREBOARD_TOP_Y = 0.0F;
 constexpr float MAIN_PLAYAREA_Y = SCOREBOARD_TOP_H;
 constexpr float SCOREBOARD_BOTTOM_Y = MAIN_PLAYAREA_Y + MAIN_PLAYAREA_H;

@@ -56,7 +59,7 @@ constexpr float PLAYAREA_PADDING_H = Game::WIDTH * PLAYAREA_PADDING_HORIZONTAL_P
 // Marcador superior (reservat per a futur ús)
 // Ocupa: 10% superior (0-48px)
 constexpr SDL_FRect SCOREBOARD_TOP = {
-    0.0f,                             // x = 0.0
+    0.0F,                             // x = 0.0
    SCOREBOARD_TOP_Y,                 // y = 0.0
    static_cast<float>(Game::WIDTH),  // w = 640.0
    SCOREBOARD_TOP_H                  // h = 48.0
@@ -65,7 +68,7 @@ constexpr SDL_FRect SCOREBOARD_TOP = {
 // Àrea de joc principal (contenidor del 80% central, sense padding)
 // Ocupa: 10-90% (48-432px), ample complet
 constexpr SDL_FRect MAIN_PLAYAREA = {
-    0.0f,                             // x = 0.0
+    0.0F,                             // x = 0.0
    MAIN_PLAYAREA_Y,                  // y = 48.0
    static_cast<float>(Game::WIDTH),  // w = 640.0
    MAIN_PLAYAREA_H                   // h = 384.0
@@ -75,23 +78,23 @@ constexpr SDL_FRect MAIN_PLAYAREA = {
 // 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)
+    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
+    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;
+constexpr float SCOREBOARD_PADDING_H = 0.0F;  // Game::WIDTH * 0.015f;
 }  // namespace Zones

 // Objetos del juego
@@ -100,144 +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 ENEMY_RADIUS = 20.0f;
-constexpr float BULLET_RADIUS = 3.0f;
+constexpr float SHIP_RADIUS = 12.0F;
+constexpr float ENEMY_RADIUS = 20.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
+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)
+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 GAME_OVER_DURATION = 5.0f;               // Seconds to display game over
-constexpr float COLLISION_SHIP_ENEMY_AMPLIFIER = 0.80f;  // 80% hitbox (generous)
+constexpr int STARTING_LIVES = 3;                          // Initial lives
+constexpr float DEATH_DURATION = 3.0F;                     // Seconds of death animation
+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_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)
+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
+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)
+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
+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;
+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;
+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;
+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;
+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
+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
+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 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
+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
+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
+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
+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
+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 ACCELERATION = 400.0f;   // px/s²
-constexpr float MAX_VELOCITY = 120.0f;   // px/s
-constexpr float FRICTION = 20.0f;        // px/s²
-constexpr float ENEMY_SPEED = 2.0f;      // unidades/frame
-constexpr float BULLET_SPEED = 6.0f;     // unidades/frame
-constexpr float VELOCITY_SCALE = 20.0f;  // factor conversión frame→tiempo
+constexpr float ROTATION_SPEED = 3.14F;  // rad/s (~180°/s)
+constexpr float ACCELERATION = 400.0F;   // px/s²
+constexpr float MAX_VELOCITY = 120.0F;   // px/s
+constexpr float FRICTION = 20.0F;        // px/s²
+constexpr float ENEMY_SPEED = 2.0F;      // unidades/frame
+constexpr float BULLET_SPEED = 6.0F;     // unidades/frame
+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 VARIACIO_VELOCITAT = 40.0f;  // ±variació aleatòria (px/s)
-constexpr float ACCELERACIO = -60.0f;        // Fricció/desacceleració (px/s²)
-constexpr float ROTACIO_MIN = 0.1f;          // Rotació mínima (rad/s ~5.7°/s)
-constexpr float ROTACIO_MAX = 0.3f;          // Rotació màxima (rad/s ~17.2°/s)
-constexpr float TEMPS_VIDA = 2.0f;           // Duració màxima (segons) - enemy/bullet debris
-constexpr float TEMPS_VIDA_NAU = 3.0f;       // Ship debris lifetime (matches DEATH_DURATION)
-constexpr float SHRINK_RATE = 0.5f;          // Reducció de mida (factor/s)
+constexpr float VELOCITAT_BASE = 80.0F;      // Velocitat inicial (px/s)
+constexpr float VARIACIO_VELOCITAT = 40.0F;  // ±variació aleatòria (px/s)
+constexpr float ACCELERACIO = -60.0F;        // Fricció/desacceleració (px/s²)
+constexpr float ROTACIO_MIN = 0.1F;          // Rotació mínima (rad/s ~5.7°/s)
+constexpr float ROTACIO_MAX = 0.3F;          // Rotació màxima (rad/s ~17.2°/s)
+constexpr float TEMPS_VIDA = 2.0F;           // Duració màxima (segons) - enemy/bullet debris
+constexpr float TEMPS_VIDA_NAU = 3.0F;       // Ship debris lifetime (matches DEATH_DURATION)
+constexpr float SHRINK_RATE = 0.5F;          // Reducció de mida (factor/s)

 // Herència de velocitat angular (trayectorias curvas)
-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²)
+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)
+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
@@ -261,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 ENEMIC = 0.7f;  // 30% més tènue (destaca menys)
-constexpr float BALA = 1.0f;    // Brillo a tope (màxima visibilitat)
+constexpr float NAU = 1.0F;     // Màxima visibilitat (jugador)
+constexpr float ENEMIC = 0.7F;  // 30% més tènue (destaca menys)
+constexpr float BALA = 1.0F;    // Brillo a tope (màxima visibilitat)

 // Starfield: gradient segons distància al centre
 // distancia_centre: 0.0 (centre) → 1.0 (vora pantalla)
 // brightness = MIN + (MAX - MIN) * distancia_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_MIN = 0.3F;  // Estrelles llunyanes (prop del centre)
+constexpr float STARFIELD_MAX = 0.8F;  // Estrelles properes (vora pantalla)
 }  // namespace Brightness

 // Renderització (V-Sync i altres opcions de render)
@@ -328,68 +332,68 @@ constexpr SDL_Keycode SHOOT = SDLK_LSHIFT;
 namespace Enemies {
 // Pentagon (esquivador - zigzag evasion)
 namespace Pentagon {
-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_MAX = 1.0f;    // Max random angle change (rad)
-constexpr float DROTACIO_MIN = 0.75f;      // Min visual rotation (rad/s) [+50%]
-constexpr float DROTACIO_MAX = 3.75f;      // Max visual rotation (rad/s) [+50%]
+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_MAX = 1.0F;    // Max random angle change (rad)
+constexpr float DROTACIO_MIN = 0.75F;      // Min visual rotation (rad/s) [+50%]
+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 TRACKING_STRENGTH = 0.5f;  // Interpolation toward player (0.0-1.0)
-constexpr float TRACKING_INTERVAL = 1.0f;  // Seconds between angle updates
-constexpr float DROTACIO_MIN = 0.3f;       // Slow rotation [+50%]
-constexpr float DROTACIO_MAX = 1.5f;       // [+50%]
+constexpr float VELOCITAT = 40.0F;         // px/s (medium speed)
+constexpr float TRACKING_STRENGTH = 0.5F;  // Interpolation toward player (0.0-1.0)
+constexpr float TRACKING_INTERVAL = 1.0F;  // Seconds between angle updates
+constexpr float DROTACIO_MIN = 0.3F;       // Slow rotation [+50%]
+constexpr float DROTACIO_MAX = 1.5F;       // [+50%]
 constexpr const char* SHAPE_FILE = "enemy_square.shp";
 }  // namespace Quadrat

 // Molinillo (agressiu - fast straight lines, proximity spin-up)
 namespace Molinillo {
-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_MAX = 0.3f;                // Small angle adjustments
-constexpr float DROTACIO_MIN = 3.0f;                   // Base rotation (rad/s) [+50%]
-constexpr float DROTACIO_MAX = 6.0f;                   // [+50%]
-constexpr float DROTACIO_PROXIMITY_MULTIPLIER = 3.0f;  // Spin-up multiplier when near ship
-constexpr float PROXIMITY_DISTANCE = 100.0f;           // Distance threshold (px)
+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_MAX = 0.3F;                // Small angle adjustments
+constexpr float DROTACIO_MIN = 3.0F;                   // Base rotation (rad/s) [+50%]
+constexpr float DROTACIO_MAX = 6.0F;                   // [+50%]
+constexpr float DROTACIO_PROXIMITY_MULTIPLIER = 3.0F;  // Spin-up multiplier when near ship
+constexpr float PROXIMITY_DISTANCE = 100.0F;           // Distance threshold (px)
 constexpr const char* SHAPE_FILE = "enemy_pinwheel.shp";
 }  // namespace Molinillo

 // Animation parameters (shared)
 namespace Animation {
 // Palpitation
-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_MAX = 3.0f;    // Max duration (seconds)
-constexpr float PALPITACIO_AMPLITUD_MIN = 0.08f;  // Min 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_MAX = 3.0f;       // Max frequency (Hz)
+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_MAX = 3.0F;    // Max duration (seconds)
+constexpr float PALPITACIO_AMPLITUD_MIN = 0.08F;  // Min 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_MAX = 3.0F;       // Max frequency (Hz)

 // Rotation acceleration
-constexpr float ROTACIO_ACCEL_TRIGGER_PROB = 0.02f;   // 2% chance per second [4x more frequent]
-constexpr float ROTACIO_ACCEL_DURACIO_MIN = 3.0f;     // Min transition time
-constexpr float ROTACIO_ACCEL_DURACIO_MAX = 8.0f;     // Max transition time
-constexpr float ROTACIO_ACCEL_MULTIPLIER_MIN = 0.3f;  // Min speed multiplier [more dramatic]
-constexpr float ROTACIO_ACCEL_MULTIPLIER_MAX = 4.0f;  // Max speed multiplier [more dramatic]
+constexpr float 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_MAX = 8.0F;     // Max transition time
+constexpr float ROTACIO_ACCEL_MULTIPLIER_MIN = 0.3F;  // Min speed multiplier [more dramatic]
+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_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
+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)
@@ -409,53 +413,53 @@ namespace Ships {
 // ============================================================

 // 1. Escala global de les naus
-constexpr float SHIP_BASE_SCALE = 2.5f;  // Multiplicador (1.0 = mida original del .shp)
+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;
+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
+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)
+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
+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)
+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
+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);
+    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;
+    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);
+    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;
+    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
+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
@@ -470,58 +474,58 @@ constexpr float VANISHING_POINT_Y = CENTER_Y;  // 240.0f
 // ============================================================

 // Durades d'animació
-constexpr float ENTRY_DURATION = 2.0f;  // Entrada (segons)
-constexpr float EXIT_DURATION = 1.0f;   // Sortida (segons)
+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)
+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°)
+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
+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
+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
+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
+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)
+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
+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;
+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 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

--- a/source/core/entities/entitat.hpp
+++ b/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
--- a/source/core/graphics/shape.cpp
+++ b/source/core/graphics/shape.cpp
@@ -11,8 +11,8 @@
 namespace Graphics {

 Shape::Shape(const std::string& filepath)
-    : centre_({0.0f, 0.0f}),
-      escala_defecte_(1.0f),
+    : centre_({.x = 0.0F, .y = 0.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;
-                escala_defecte_ = 1.0f;
+                std::cerr << "[Shape] Warning: escala invàlida, usant 1.0" << '\n';
+                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;
-            centre_ = {0.0f, 0.0f};
+            std::cerr << "[Shape] Warning: centre invàlid, usant (0,0)" << '\n';
+            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';
            }
        }
    }
--- a/source/core/graphics/shape.hpp
+++ b/source/core/graphics/shape.hpp
@@ -36,16 +36,16 @@ class Shape {
        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_; }
-        float get_escala_defecte() const { return escala_defecte_; }
-        bool es_valida() const { return !primitives_.empty(); }
+        [[nodiscard]] const Punt& get_centre() const { return centre_; }
+        [[nodiscard]] float get_escala_defecte() const { return escala_defecte_; }
+        [[nodiscard]] bool es_valida() const { return !primitives_.empty(); }

        // Info de depuració
-        std::string get_nom() const { return nom_; }
-        size_t get_num_primitives() const { return primitives_.size(); }
+        [[nodiscard]] std::string get_nom() const { return nom_; }
+        [[nodiscard]] size_t get_num_primitives() const { return primitives_.size(); }

    private:
        std::vector<ShapePrimitive> primitives_;
@@ -54,11 +54,11 @@ class Shape {
        std::string nom_;       // Nom de la forma (per depuració)

        // Helpers privats per parsejar
-        std::string trim(const std::string& str) const;
-        bool starts_with(const std::string& str, const std::string& prefix) const;
-        std::string extract_value(const std::string& line) const;
+        [[nodiscard]] std::string trim(const std::string& str) const;
+        [[nodiscard]] bool starts_with(const std::string& str, const std::string& prefix) const;
+        [[nodiscard]] std::string extract_value(const std::string& line) const;
        void parse_center(const std::string& value);
-        std::vector<Punt> parse_points(const std::string& str) const;
+        [[nodiscard]] std::vector<Punt> parse_points(const std::string& str) const;
 };

 }  // namespace Graphics
--- a/source/core/graphics/shape_loader.cpp
+++ b/source/core/graphics/shape_loader.cpp
@@ -17,14 +17,14 @@ 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
    }

    // Normalize path: "ship.shp" → "shapes/ship.shp"
    //                 "logo/letra_j.shp" → "shapes/logo/letra_j.shp"
    std::string normalized = filename;
-    if (normalized.find("shapes/") != 0) {
+    if (!normalized.starts_with("shapes/")) {
        // Doesn't start with "shapes/", so add it
        normalized = "shapes/" + normalized;
    }
@@ -33,7 +33,7 @@ std::shared_ptr<Shape> ShapeLoader::load(const std::string& filename) {
    std::vector<uint8_t> data = Resource::Helper::loadFile(normalized);
    if (data.empty()) {
        std::cerr << "[ShapeLoader] Error: no s'ha pogut carregar " << normalized
-                  << std::endl;
+                  << '\n';
        return nullptr;
    }

@@ -42,19 +42,19 @@ std::shared_ptr<Shape> ShapeLoader::load(const std::string& filename) {
    auto shape = std::make_shared<Shape>();
    if (!shape->parsejar_fitxer(file_content)) {
        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 " << normalized << std::endl;
+        std::cerr << "[ShapeLoader] Error: forma invàlida " << normalized << '\n';
        return nullptr;
    }

    // Cache and return
    std::cout << "[ShapeLoader] Carregat: " << normalized << " (" << shape->get_nom()
-              << ", " << shape->get_num_primitives() << " primitives)" << std::endl;
+              << ", " << shape->get_num_primitives() << " primitives)" << '\n';

    cache_[filename] = shape;
    return shape;
@@ -62,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();
 }

@@ -75,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;
    }

--- a/source/core/graphics/starfield.cpp
+++ b/source/core/graphics/starfield.cpp
@@ -26,24 +26,24 @@ Starfield::Starfield(SDL_Renderer* renderer,
    shape_estrella_ = ShapeLoader::load("star.shp");

    if (!shape_estrella_ || !shape_estrella_->es_valida()) {
-        std::cerr << "ERROR: No s'ha pogut carregar 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++) {
@@ -53,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.y = punt_fuga_.y + radi * std::sin(estrella.angle);
+            estrella.posicio.x = punt_fuga_.x + (radi * std::cos(estrella.angle));
+            estrella.posicio.y = punt_fuga_.y + (radi * std::sin(estrella.angle));

            estrelles_.push_back(estrella);
        }
@@ -69,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.y = punt_fuga_.y + radi * std::sin(estrella.angle);
+    estrella.posicio.x = punt_fuga_.x + (radi * std::cos(estrella.angle));
+    estrella.posicio.y = punt_fuga_.y + (radi * std::sin(estrella.angle));
 }

 // Verificar si una estrella està fora de l'àrea
@@ -97,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
@@ -105,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) *
-            estrella.distancia_centre;
+        ((Defaults::Brightness::STARFIELD_MAX - Defaults::Brightness::STARFIELD_MIN) *
+            estrella.distancia_centre);

    // Aplicar multiplicador i limitar a 1.0
-    return std::min(1.0f, brightness_base * multiplicador_brightness_);
+    return std::min(1.0F, brightness_base * multiplicador_brightness_);
 }

 // Actualitzar posicions de les estrelles
@@ -129,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
@@ -141,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
@@ -160,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
        );
    }
--- a/source/core/graphics/starfield.hpp
+++ b/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
--- a/source/core/graphics/vector_text.cpp
+++ b/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_height = 40.0f;  // Altura 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

 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, float brightness) {
-    if (!renderer_) {
+void VectorText::render(const std::string& text, const Punt& posicio, float escala, float spacing, float brightness) const {
+    if (renderer_ == nullptr) {
        return;
    }

@@ -201,7 +202,7 @@ void VectorText::render(const std::string& text, const Punt& posicio, float esca

    // 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() &&
@@ -222,21 +223,21 @@ void VectorText::render(const std::string& text, const Punt& posicio, float esca
            // Renderizar carácter
            // Ajustar X e Y para que posicio represente esquina superior izquierda
            // (render_shape espera el centro, así que sumamos la mitad de ancho y altura)
-            Punt char_pos = {current_x + char_width_scaled / 2.0f, posicio.y + char_height_scaled / 2.0f};
-            Rendering::render_shape(renderer_, it->second, char_pos, 0.0f, escala, true, 1.0f, brightness);
+            Punt char_pos = {.x = current_x + (char_width_scaled / 2.0F), .y = posicio.y + (char_height_scaled / 2.0F)};
+            Rendering::render_shape(renderer_, it->second, char_pos, 0.0F, escala, true, 1.0F, brightness);

            // 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) {
+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);
@@ -244,8 +245,8 @@ void VectorText::render_centered(const std::string& text, const Punt& centre_pun
    // Calcular posició de l'esquina superior esquerra
    // restant la meitat de les dimensions del punt central
    Punt posicio_esquerra = {
-        centre_punt.x - (text_width / 2.0f),
-        centre_punt.y - (text_height / 2.0f)};
+        .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);
@@ -253,7 +254,7 @@ void VectorText::render_centered(const std::string& text, const Punt& centre_pun

 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;
@@ -262,7 +263,7 @@ float VectorText::get_text_width(const std::string& text, float escala, float sp
    // Contar caracteres visuals (no bytes) - manejar UTF-8
    size_t visual_chars = 0;
    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) - igual que render()
        if (c == 0xC2 && i + 1 < text.length() &&
@@ -275,7 +276,7 @@ float VectorText::get_text_width(const std::string& text, float escala, float sp
    }

    // Ancho total = todos los caracteres VISUALES + spacing entre ellos
-    return visual_chars * char_width_scaled + (visual_chars - 1) * spacing_scaled;
+    return (visual_chars * char_width_scaled) + ((visual_chars - 1) * spacing_scaled);
 }

 float VectorText::get_text_height(float escala) const {
--- a/source/core/graphics/vector_text.hpp
+++ b/source/core/graphics/vector_text.hpp
@@ -25,7 +25,7 @@ class VectorText {
        // - escala: factor de escala (1.0 = 20×40 px por carácter)
        // - spacing: espacio entre caracteres en píxeles (a escala 1.0)
        // - brightness: factor de brillantor (0.0-1.0, default 1.0 = màxima brillantor)
-        void render(const std::string& text, const Punt& posicio, float escala = 1.0f, float spacing = 2.0f, float brightness = 1.0f);
+        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
@@ -33,23 +33,23 @@ class VectorText {
        // - 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);
+        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
--- a/source/core/input/input.cpp
+++ b/source/core/input/input.cpp
@@ -506,7 +506,7 @@ void Input::applyPlayer1BindingsFromOptions() {
    std::shared_ptr<Gamepad> gamepad = nullptr;
    if (Options::player1.gamepad_name.empty()) {
        // Fallback: usar primer gamepad disponible
-        gamepad = (gamepads_.size() > 0) ? gamepads_[0] : nullptr;
+        gamepad = (!gamepads_.empty()) ? gamepads_[0] : nullptr;
    } else {
        // Buscar por nombre
        gamepad = findAvailableGamepadByName(Options::player1.gamepad_name);
--- a/source/core/input/input.hpp
+++ b/source/core/input/input.hpp
@@ -115,12 +115,12 @@ class Input {
        // --- Gestión de gamepads ---
        [[nodiscard]] auto gameControllerFound() const -> bool;
        [[nodiscard]] auto getNumGamepads() const -> int;
-        auto getGamepad(SDL_JoystickID id) const -> std::shared_ptr<Gamepad>;
-        auto getGamepadByName(const std::string& name) const -> std::shared_ptr<Input::Gamepad>;
-        auto getGamepads() const -> const Gamepads& { return gamepads_; }
+        [[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;
-        auto getControllerNames() const -> std::vector<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;

--- a/source/core/input/mouse.cpp
+++ b/source/core/input/mouse.cpp
@@ -19,12 +19,12 @@ 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" << std::endl;
+              << " -> 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" << std::endl;
+    std::cout << "[Mouse::forceHide] Ignorant moviments durant " << IGNORE_MOTION_DURATION << "ms" << '\n';
 }

 void setForceHidden(bool force) {
@@ -59,13 +59,13 @@ void handleEvent(const SDL_Event& event) {
        // 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)" << std::endl;
+                      << " (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 << std::endl;
+            std::cout << "[Mouse::handleEvent] Mostrant cursor per moviment REAL. time=" << last_mouse_move_time << '\n';
            SDL_ShowCursor();
            cursor_visible = true;
        }
@@ -82,7 +82,7 @@ void updateCursorVisibility() {
    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) << std::endl;
+                  << " last=" << last_mouse_move_time << " diff=" << (current_time - last_mouse_move_time) << '\n';
        SDL_HideCursor();
        cursor_visible = false;
    }
--- a/source/core/math/easing.hpp
+++ b/source/core/math/easing.hpp
@@ -9,7 +9,7 @@ namespace Easing {
 // 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);
+    return 1.0F - ((1.0F - t) * (1.0F - t));
 }

 // Ease-in quadratic: empieza lento, acelera
@@ -23,22 +23,22 @@ inline float ease_in_quad(float t) {
 // 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;
+    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;
+    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;
+    return start + ((end - start) * t);
 }

 }  // namespace Easing
--- a/source/core/physics/collision.hpp
+++ b/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
--- a/source/core/rendering/color_oscillator.cpp
+++ b/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,
-        Defaults::Color::LINE_MIN_G,
-        Defaults::Color::LINE_MIN_B,
-        255};
-    current_background_color_ = {Defaults::Color::BACKGROUND_MIN_R,
-        Defaults::Color::BACKGROUND_MIN_G,
-        Defaults::Color::BACKGROUND_MIN_B,
-        255};
+    current_line_color_ = {.r = Defaults::Color::LINE_MIN_R,
+        .g = Defaults::Color::LINE_MIN_G,
+        .b = Defaults::Color::LINE_MIN_B,
+        .a = 255};
+    current_background_color_ = {.r = Defaults::Color::BACKGROUND_MIN_R,
+        .g = Defaults::Color::BACKGROUND_MIN_G,
+        .b = Defaults::Color::BACKGROUND_MIN_B,
+        .a = 255};
 }

 void ColorOscillator::update(float delta_time) {
@@ -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;
-    return (std::sin(radians) + 1.0f) / 2.0f;
+    float radians = time * frequency * 2.0F * Defaults::Math::PI;
+    return (std::sin(radians) + 1.0F) / 2.0F;
 }

 SDL_Color ColorOscillator::interpolateColor(SDL_Color min, SDL_Color max, float factor) {
-    return {static_cast<uint8_t>(min.r + (max.r - min.r) * factor),
-        static_cast<uint8_t>(min.g + (max.g - min.g) * factor),
-        static_cast<uint8_t>(min.b + (max.b - min.b) * factor),
+    return {static_cast<uint8_t>(min.r + ((max.r - min.r) * factor)),
+        static_cast<uint8_t>(min.g + ((max.g - min.g) * factor)),
+        static_cast<uint8_t>(min.b + ((max.b - min.b) * factor)),
        255};
 }

--- a/source/core/rendering/color_oscillator.hpp
+++ b/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_; }
-        SDL_Color getCurrentBackgroundColor() const {
+        [[nodiscard]] SDL_Color getCurrentLineColor() const { return current_line_color_; }
+        [[nodiscard]] SDL_Color getCurrentBackgroundColor() const {
            return current_background_color_;
        }

--- a/source/core/rendering/coordinate_transform.cpp
+++ b/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
--- a/source/core/rendering/line_renderer.cpp
+++ b/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);
--- a/source/core/rendering/line_renderer.hpp
+++ b/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);
--- a/source/core/rendering/primitives.cpp
+++ b/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 act = 0.0f;
+    float interval = 2.0F * Defaults::Math::PI / n;
+    float act = 0.0F;

    for (uint8_t i = 0; i < n; i++) {
        pol.ipuntx[i].r = r;
@@ -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.y = 200.0f;
-    pol.angle = 0.0f;
+    pol.centre.x = 320.0F;
+    pol.centre.y = 200.0F;
+    pol.angle = 0.0F;
    // Convertir velocitat de px/frame a px/s: 2 px/frame × 20 FPS = 40 px/s
-    pol.velocitat = Defaults::Physics::ENEMY_SPEED * 20.0f;
+    pol.velocitat = Defaults::Physics::ENEMY_SPEED * 20.0F;
    pol.n = n;
    // Convertir rotació de rad/frame a rad/s: 0.0785 rad/frame × 20 FPS = 1.57
    // rad/s (~90°/s)
-    pol.drotacio = 0.078539816f * 20.0f;
-    pol.rotacio = 0.0f;
+    pol.drotacio = 0.078539816F * 20.0F;
+    pol.rotacio = 0.0F;
    pol.esta = true;
 }
--- a/source/core/rendering/sdl_manager.cpp
+++ b/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_) {
-        std::cerr << "Error creant finestra: " << SDL_GetError() << std::endl;
+    if (finestra_ == nullptr) {
+        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_) {
-        std::cerr << "Error creant renderer: " << SDL_GetError() << std::endl;
+    if (renderer_ == nullptr) {
+        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_) {
-        std::cerr << "Error creant finestra: " << SDL_GetError() << std::endl;
+    if (finestra_ == nullptr) {
+        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_) {
-        std::cerr << "Error creant renderer: " << SDL_GetError() << std::endl;
+    if (renderer_ == nullptr) {
+        std::cerr << "Error creant renderer: " << SDL_GetError() << '\n';
        SDL_DestroyWindow(finestra_);
        SDL_Quit();
        return;
@@ -153,41 +153,41 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
    if (is_fullscreen_) {
        std::cout << " [FULLSCREEN]";
    }
-    std::cout << std::endl;
+    std::cout << '\n';
 }

 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
@@ -209,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) {
@@ -221,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;
    }

@@ -249,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() {
@@ -279,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_;
@@ -349,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;
@@ -359,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_;
@@ -389,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;
@@ -409,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_);
 }
@@ -430,10 +435,10 @@ 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 vsync_state = (Options::rendering.vsync == 1) ? "ON" : "OFF";
@@ -444,7 +449,7 @@ void SDLManager::updateFPS(float delta_time) {
            fps_display_,
            vsync_state);

-        if (finestra_) {
+        if (finestra_ != nullptr) {
            SDL_SetWindowTitle(finestra_, title.c_str());
        }
    }
@@ -452,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());
    }
 }
@@ -463,12 +468,12 @@ 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_accumulator_ = 0.0F;
    fps_frame_count_ = 0;

    // Guardar configuració
--- a/source/core/rendering/sdl_manager.hpp
+++ b/source/core/rendering/sdl_manager.hpp
@@ -40,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_;
--- a/source/core/rendering/shape_renderer.cpp
+++ b/source/core/rendering/shape_renderer.cpp
@@ -12,33 +12,33 @@ 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
+    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;
+    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;
+    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;
+    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;
+    constexpr float perspective_factor = 500.0F;
    float scale_factor = perspective_factor / (perspective_factor + z2);

-    return {x3 * scale_factor, y3 * scale_factor};
+    return {.x = x3 * scale_factor, .y = y3 * scale_factor};
 }

 // Helper: transformar un punt amb rotació, escala i trasllació
@@ -48,7 +48,7 @@ static Punt transform_point(const Punt& point, const Punt& shape_centre, const P
    float centered_y = point.y - shape_centre.y;

    // 2. Aplicar rotació 3D (si es proporciona)
-    if (rotation_3d && rotation_3d->has_rotation()) {
+    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;
@@ -65,11 +65,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_y = scaled_x * sin_a + scaled_y * cos_a;
+    float rotated_x = (scaled_x * cos_a) - (scaled_y * sin_a);
+    float rotated_y = (scaled_x * sin_a) + (scaled_y * cos_a);

    // 5. Aplicar trasllació a posició mundial
-    return {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,
@@ -87,7 +87,7 @@ void render_shape(SDL_Renderer* renderer,
    }

    // Si progress < 1.0, no dibuixar (tot o res)
-    if (progress < 1.0f) {
+    if (progress < 1.0F) {
        return;
    }

--- a/source/core/rendering/shape_renderer.hpp
+++ b/source/core/rendering/shape_renderer.hpp
@@ -19,16 +19,16 @@ struct Rotation3D {
        float roll;   // Rotació eix Z (alabeo lateral)

        Rotation3D()
-            : pitch(0.0f),
-              yaw(0.0f),
-              roll(0.0f) {}
+            : 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;
+        [[nodiscard]] bool has_rotation() const {
+            return pitch != 0.0F || yaw != 0.0F || roll != 0.0F;
        }
 };

@@ -45,10 +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 brightness = 1.0f,
+    float progress = 1.0F,
+    float brightness = 1.0F,
    const Rotation3D* rotation_3d = nullptr);

 }  // namespace Rendering
--- a/source/core/resources/resource_helper.cpp
+++ b/source/core/resources/resource_helper.cpp
@@ -8,8 +8,7 @@

 #include "resource_loader.hpp"

-namespace Resource {
-namespace Helper {
+namespace Resource::Helper {

 // Inicialitzar el sistema de recursos
 bool initializeResourceSystem(const std::string& pack_file, bool fallback) {
@@ -79,5 +78,4 @@ bool isPackLoaded() {
    return Loader::get().isPackLoaded();
 }

-}  // namespace Helper
-}  // namespace Resource
+}  // namespace Resource::Helper
--- a/source/core/resources/resource_helper.hpp
+++ b/source/core/resources/resource_helper.hpp
@@ -4,11 +4,11 @@

 #pragma once

+#include <cstdint>
 #include <string>
 #include <vector>

-namespace Resource {
-namespace Helper {
+namespace Resource::Helper {

 // Inicialització del sistema
 bool initializeResourceSystem(const std::string& pack_file, bool fallback);
@@ -24,5 +24,4 @@ std::string normalizePath(const std::string& path);
 // Estat
 bool isPackLoaded();

-}  // namespace Helper
-}  // namespace Resource
+}  // namespace Resource::Helper
--- a/source/core/resources/resource_loader.hpp
+++ b/source/core/resources/resource_loader.hpp
@@ -27,20 +27,20 @@ class Loader {

        // Validació
        bool validatePack();
-        bool isPackLoaded() const;
+        [[nodiscard]] bool isPackLoaded() const;

        // Estat
        void setBasePath(const std::string& path);
-        std::string getBasePath() const;
-
-    private:
-        Loader() = default;
-        ~Loader() = default;
+        [[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;
--- a/source/core/resources/resource_pack.cpp
+++ b/source/core/resources/resource_pack.cpp
@@ -197,7 +197,7 @@ bool Pack::loadPack(const std::string& pack_file) {
        file.read(reinterpret_cast<char*>(&name_len), sizeof(name_len));

        std::string filename(name_len, '\0');
-        file.read(&filename[0], name_len);
+        file.read(filename.data(), name_len);

        // Offset, mida, checksum
        ResourceEntry entry;
@@ -258,7 +258,7 @@ std::vector<uint8_t> Pack::getResource(const std::string& filename) {

 // Comprovar si existeix un recurs
 bool Pack::hasResource(const std::string& filename) const {
-    return resources_.find(filename) != resources_.end();
+    return resources_.contains(filename);
 }

 // Obtenir llista de tots els recursos
--- a/source/core/resources/resource_pack.hpp
+++ b/source/core/resources/resource_pack.hpp
@@ -41,11 +41,11 @@ class Pack {

        // Accés a recursos
        std::vector<uint8_t> getResource(const std::string& filename);
-        bool hasResource(const std::string& filename) const;
-        std::vector<std::string> getResourceList() const;
+        [[nodiscard]] bool hasResource(const std::string& filename) const;
+        [[nodiscard]] std::vector<std::string> getResourceList() const;

        // Validació
-        bool validatePack() const;
+        [[nodiscard]] bool validatePack() const;

    private:
        // Constants
@@ -59,7 +59,7 @@ class Pack {

        // Funcions auxiliars
        std::vector<uint8_t> readFile(const std::string& filepath);
-        uint32_t calculateChecksum(const std::vector<uint8_t>& data) const;
+        [[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);
 };
--- a/source/core/system/context_escenes.hpp
+++ b/source/core/system/context_escenes.hpp
@@ -27,9 +27,7 @@ class ContextEscenes {
        };

        // Constructor inicial amb escena LOGO i sense opcions
-        ContextEscenes()
-            : escena_desti_(Escena::LOGO),
-              opcio_(Opcio::NONE) {}
+        ContextEscenes() = default;

        // Canviar escena amb opció específica
        void canviar_escena(Escena nova_escena, Opcio opcio = Opcio::NONE) {
@@ -71,8 +69,8 @@ class ContextEscenes {
        }

    private:
-        Escena escena_desti_;                       // Escena a la qual transicionar
-        Opcio opcio_;                               // Opció específica per l'escena
+        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)
 };

--- a/source/core/system/game_config.hpp
+++ b/source/core/system/game_config.hpp
@@ -42,8 +42,12 @@ struct ConfigPartida {
        // 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;
+            if (jugador1_actiu && !jugador2_actiu) {
+                return 0;
+            }
+            if (!jugador1_actiu && jugador2_actiu) {
+                return 1;
+            }
            return 0;  // Fallback (cal comprovar es_un_jugador() primer)
        }
 };
--- a/source/core/system/global_events.cpp
+++ b/source/core/system/global_events.cpp
@@ -20,7 +20,7 @@ bool handle(const SDL_Event& event, SDLManager& sdl, ContextEscenes& context) {
    // 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 << std::endl;
+        std::cout << "[Input] " << event_msg << '\n';
    }

    // 2. Procesar SDL_EVENT_QUIT directamente (no es input de juego)
--- a/source/core/utils/path_utils.cpp
+++ b/source/core/utils/path_utils.cpp
@@ -15,7 +15,7 @@ static std::string executable_directory_;

 // Inicialitzar el sistema de rutes amb argv[0]
 void initializePathSystem(const char* argv0) {
-    if (!argv0) {
+    if (argv0 == nullptr) {
        std::cerr << "[PathUtils] ADVERTÈNCIA: argv[0] és nullptr\n";
        executable_path_ = "";
        executable_directory_ = ".";
@@ -65,10 +65,8 @@ std::string getResourceBasePath() {
        // Bundle de macOS: recursos a ../Resources des de MacOS/
        std::cout << "[PathUtils] Detectat bundle de macOS\n";
        return exe_dir + "/../Resources";
-    } else {
-        // Executable normal: recursos al mateix directori
-        return exe_dir;
-    }
+    }  // Executable normal: recursos al mateix directori
+    return exe_dir;
 }

 // Normalitzar ruta (convertir barres, etc.)
--- a/source/external/.clang-tidy
+++ b/source/external/.clang-tidy
@@ -0,0 +1,4 @@
+# source/external/.clang-tidy
+Checks: '-*'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
--- a/source/game/constants.hpp
+++ b/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_y = zona.y + zona.h / 2.0f;
+    centre_x = zona.x + (zona.w / 2.0F);
+    centre_y = zona.y + (zona.h / 2.0F);
 }
 }  // namespace Constants
--- a/source/game/effects/debris_manager.cpp
+++ b/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_y = scaled_x * sin_a + scaled_y * cos_a;
+    float rotated_x = (scaled_x * cos_a) - (scaled_y * sin_a);
+    float rotated_y = (scaled_x * sin_a) + (scaled_y * cos_a);

    // 4. Aplicar trasllació a posició mundial
-    return {rotated_x + posicio.x, rotated_y + posicio.y};
+    return {.x = rotated_x + posicio.x, .y = rotated_y + posicio.y};
 }

 DebrisManager::DebrisManager(SDL_Renderer* renderer)
@@ -71,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]);
            }
        }

@@ -90,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
            }
@@ -105,42 +106,42 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
            // 5. Velocitat inicial (base ± variació aleatòria + velocitat heretada)
            float speed =
                velocitat_base +
-                ((std::rand() / static_cast<float>(RAND_MAX)) * 2.0f - 1.0f) *
-                    Defaults::Physics::Debris::VARIACIO_VELOCITAT;
+                (((std::rand() / static_cast<float>(RAND_MAX)) * 2.0F - 1.0F) *
+                    Defaults::Physics::Debris::VARIACIO_VELOCITAT);

            // Heredar velocitat de l'objecte original (suma vectorial)
-            debris->velocitat.x = direccio.x * speed + velocitat_objecte.x;
-            debris->velocitat.y = direccio.y * speed + velocitat_objecte.y;
+            debris->velocitat.x = (direccio.x * speed) + velocitat_objecte.x;
+            debris->velocitat.y = (direccio.y * speed) + velocitat_objecte.y;
            debris->acceleracio = Defaults::Physics::Debris::ACCELERACIO;

            // 6. Herència de velocitat angular amb cap + conversió d'excés

            // 6a. Rotació de TRAYECTORIA amb cap + conversió tangencial
-            if (std::abs(velocitat_angular) > 0.01f) {
+            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)) *
+                    ((std::rand() / static_cast<float>(RAND_MAX)) *
                        (Defaults::Physics::Debris::FACTOR_HERENCIA_MAX -
-                            Defaults::Physics::Debris::FACTOR_HERENCIA_MIN);
+                            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);
+                    ((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;
+                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;
+                    float radius = 20.0F;

                    // Velocitat tangencial = ω_excés × radi
                    float v_tangential = excess * radius;
@@ -161,25 +162,25 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
                    debris->velocitat_rot = velocitat_ang_heretada;
                }
            } else {
-                debris->velocitat_rot = 0.0f;  // Nave: sin curvas
+                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) {
+            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);
+                    ((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) {
@@ -187,10 +188,10 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
                }
            }

-            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;

@@ -205,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;
@@ -219,29 +221,28 @@ 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 +
-            debris.velocitat.y * debris.velocitat.y);
+        float speed = std::sqrt((debris.velocitat.x * debris.velocitat.x) +
+            (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;
-            if (nova_speed < 0.0f)
-                nova_speed = 0.0f;
+            float nova_speed = speed + (debris.acceleracio * delta_time);
+            nova_speed = std::max(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.y = 0.0f;
+            debris.velocitat.x = 0.0F;
+            debris.velocitat.y = 0.0F;
        }

        // 2b. Rotar vector de velocitat (trayectoria curva)
-        if (std::abs(debris.velocitat_rot) > 0.01f) {
+        if (std::abs(debris.velocitat_rot) > 0.01F) {
            // Calcular angle de rotació aquest frame
            float dangle = debris.velocitat_rot * delta_time;

@@ -252,26 +253,26 @@ void DebrisManager::actualitzar(float delta_time) {
            float cos_a = std::cos(dangle);
            float sin_a = std::sin(dangle);

-            debris.velocitat.x = vel_x_old * cos_a - vel_y_old * sin_a;
-            debris.velocitat.y = vel_x_old * sin_a + vel_y_old * cos_a;
+            debris.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;
+        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;
+                debris.velocitat_rot = 0.0F;
            }
        }

        // 3. Calcular centre del segment
-        Punt centre = {(debris.p1.x + debris.p2.x) / 2.0f,
-            (debris.p1.y + debris.p2.y) / 2.0f};
+        Punt centre = {.x = (debris.p1.x + debris.p2.x) / 2.0F,
+            .y = (debris.p1.y + debris.p2.y) / 2.0F};

        // 4. Actualitzar posició del centre
        centre.x += debris.velocitat.x * delta_time;
@@ -282,29 +283,30 @@ void DebrisManager::actualitzar(float 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);
-        shrink_factor = std::max(0.0f, shrink_factor);  // No negatiu
+            1.0F - (debris.factor_shrink * debris.temps_vida / debris.temps_max);
+        shrink_factor = std::max(0.0F, shrink_factor);  // No negatiu

        // Calcular distància original entre punts
        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.y = centre.y - half_length * std::sin(new_angle);
-        debris.p2.x = centre.x + half_length * std::cos(new_angle);
-        debris.p2.y = centre.y + half_length * std::sin(new_angle);
+        debris.p1.x = centre.x - (half_length * std::cos(new_angle));
+        debris.p1.y = centre.y - (half_length * std::sin(new_angle));
+        debris.p2.x = centre.x + (half_length * std::cos(new_angle));
+        debris.p2.y = centre.y + (half_length * std::sin(new_angle));
    }
 }

 void DebrisManager::dibuixar() const {
    for (const auto& debris : debris_pool_) {
-        if (!debris.actiu)
+        if (!debris.actiu) {
            continue;
+        }

        // Dibuixar segment de línia amb brightness heretat
        Rendering::linea(renderer_,
@@ -330,8 +332,8 @@ Punt DebrisManager::calcular_direccio_explosio(const Punt& p1,
    const Punt& p2,
    const Punt& centre_objecte) const {
    // 1. Calcular centre del segment
-    float centro_seg_x = (p1.x + p2.x) / 2.0f;
-    float centro_seg_y = (p1.y + p2.y) / 2.0f;
+    float centro_seg_x = (p1.x + p2.x) / 2.0F;
+    float centro_seg_y = (p1.y + p2.y) / 2.0F;

    // 2. Calcular vector des del centre de l'objecte cap al centre del segment
    // Això garanteix que la direcció sempre apunte cap a fora (direcció radial)
@@ -339,12 +341,12 @@ Punt DebrisManager::calcular_direccio_explosio(const Punt& p1,
    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) {
+    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;
-        return {std::cos(angle_rand), std::sin(angle_rand)};
+            (std::rand() / static_cast<float>(RAND_MAX)) * 2.0F * Defaults::Math::PI;
+        return {.x = std::cos(angle_rand), .y = std::sin(angle_rand)};
    }

    dx /= length;
@@ -352,15 +354,15 @@ Punt DebrisManager::calcular_direccio_explosio(const Punt& p1,

    // 4. Afegir variació aleatòria petita (±15°) per varietat visual
    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 = dx * cos_v - dy * sin_v;
-    float final_y = dx * sin_v + dy * cos_v;
+    float final_x = (dx * cos_v) - (dy * sin_v);
+    float final_y = (dx * sin_v) + (dy * cos_v);

-    return {final_x, final_y};
+    return {.x = final_x, .y = final_y};
 }

 void DebrisManager::reiniciar() {
@@ -372,8 +374,9 @@ 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;
 }
--- a/source/game/effects/debris_manager.hpp
+++ b/source/game/effects/debris_manager.hpp
@@ -34,10 +34,10 @@ class DebrisManager {
            float angle,
            float escala,
            float velocitat_base,
-            float brightness = 1.0f,
-            const Punt& velocitat_objecte = {0.0f, 0.0f},
-            float velocitat_angular = 0.0f,
-            float factor_herencia_visual = 0.0f,
+            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
@@ -50,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_;
@@ -59,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ó d'explosió (radial, des del centre cap al segment)
-        Punt calcular_direccio_explosio(const Punt& p1, const Punt& p2, const Punt& centre_objecte) const;
+        [[nodiscard]] Punt calcular_direccio_explosio(const Punt& p1, const Punt& p2, const Punt& centre_objecte) const;
 };

 }  // namespace Effects
--- a/source/game/effects/gestor_puntuacio_flotant.cpp
+++ b/source/game/effects/gestor_puntuacio_flotant.cpp
@@ -8,8 +8,7 @@
 namespace Effects {

 GestorPuntuacioFlotant::GestorPuntuacioFlotant(SDL_Renderer* renderer)
-    : renderer_(renderer),
-      text_(renderer) {
+    : text_(renderer) {
    // Inicialitzar tots els slots com inactius
    for (auto& pf : pool_) {
        pf.actiu = false;
@@ -19,24 +18,26 @@ GestorPuntuacioFlotant::GestorPuntuacioFlotant(SDL_Renderer* renderer)
 void GestorPuntuacioFlotant::crear(int punts, const Punt& posicio) {
    // 1. Trobar slot lliure
    PuntuacioFlotant* pf = trobar_slot_lliure();
-    if (!pf)
+    if (pf == nullptr) {
        return;  // Pool ple (improbable)
+    }

    // 2. Inicialitzar puntuació flotant
    pf->text = std::to_string(punts);
    pf->posicio = posicio;
-    pf->velocitat = {Defaults::FloatingScore::VELOCITY_X,
-        Defaults::FloatingScore::VELOCITY_Y};
-    pf->temps_vida = 0.0f;
+    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->brightness = 1.0F;
    pf->actiu = true;
 }

 void GestorPuntuacioFlotant::actualitzar(float delta_time) {
    for (auto& pf : pool_) {
-        if (!pf.actiu)
+        if (!pf.actiu) {
            continue;
+        }

        // 1. Actualitzar posició (deriva cap amunt)
        pf.posicio.x += pf.velocitat.x * delta_time;
@@ -47,7 +48,7 @@ void GestorPuntuacioFlotant::actualitzar(float 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
+        pf.brightness = 1.0F - progress;                // 1.0 → 0.0

        // 4. Desactivar quan acaba el temps
        if (pf.temps_vida >= pf.temps_max) {
@@ -58,8 +59,9 @@ void GestorPuntuacioFlotant::actualitzar(float delta_time) {

 void GestorPuntuacioFlotant::dibuixar() {
    for (const auto& pf : pool_) {
-        if (!pf.actiu)
+        if (!pf.actiu) {
            continue;
+        }

        // Renderitzar centrat amb brightness (fade)
        constexpr float escala = Defaults::FloatingScore::SCALE;
@@ -78,16 +80,18 @@ void GestorPuntuacioFlotant::reiniciar() {
 int GestorPuntuacioFlotant::get_num_actius() const {
    int count = 0;
    for (const auto& pf : pool_) {
-        if (pf.actiu)
+        if (pf.actiu) {
            count++;
+        }
    }
    return count;
 }

 PuntuacioFlotant* GestorPuntuacioFlotant::trobar_slot_lliure() {
    for (auto& pf : pool_) {
-        if (!pf.actiu)
+        if (!pf.actiu) {
            return &pf;
+        }
    }
    return nullptr;  // Pool ple
 }
--- a/source/game/effects/gestor_puntuacio_flotant.hpp
+++ b/source/game/effects/gestor_puntuacio_flotant.hpp
@@ -35,10 +35,9 @@ class GestorPuntuacioFlotant {
        void reiniciar();

        // Obtenir número actius (debug)
-        int get_num_actius() const;
+        [[nodiscard]] int get_num_actius() const;

    private:
-        SDL_Renderer* renderer_;
        Graphics::VectorText text_;  // Sistema de text vectorial

        // Pool de números flotants (màxim concurrent)
--- a/source/game/entities/bala.cpp
+++ b/source/game/entities/bala.cpp
@@ -4,38 +4,43 @@

 #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),
-      centre_({0.0f, 0.0f}),
-      angle_(0.0f),
-      velocitat_(0.0f),
+    : Entitat(renderer),
+      velocitat_(0.0F),
      esta_(false),
-      grace_timer_(0.0f),
-      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};
-    angle_ = 0.0f;
-    velocitat_ = 0.0f;
-    grace_timer_ = 0.0f;
+    centre_ = {.x = 0.0F, .y = 0.0F};
+    angle_ = 0.0F;
+    velocitat_ = 0.0F;
+    grace_timer_ = 0.0F;
 }

 void Bala::disparar(const Punt& posicio, float angle, uint8_t owner_id) {
@@ -57,7 +62,7 @@ void Bala::disparar(const Punt& posicio, float angle, uint8_t 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;
@@ -69,11 +74,9 @@ void Bala::disparar(const Punt& posicio, float angle, uint8_t owner_id) {
 void Bala::actualitzar(float delta_time) {
    if (esta_) {
        // Decrementar grace timer
-        if (grace_timer_ > 0.0f) {
+        if (grace_timer_ > 0.0F) {
            grace_timer_ -= delta_time;
-            if (grace_timer_ < 0.0f) {
-                grace_timer_ = 0.0f;
-            }
+            grace_timer_ = std::max(grace_timer_, 0.0F);
        }

        mou(delta_time);
@@ -84,7 +87,7 @@ void Bala::dibuixar() const {
    if (esta_ && forma_) {
        // [NUEVO] Usar render_shape en lloc de rota_pol
        // Les bales roten segons l'angle de trajectòria
-        Rendering::render_shape(renderer_, forma_, centre_, angle_, 1.0f, true, 1.0f, brightness_);
+        Rendering::render_shape(renderer_, forma_, centre_, angle_, 1.0F, true, 1.0F, brightness_);
    }
 }

@@ -98,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 dx = velocitat_efectiva * std::cos(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));

    // Acumulació directa amb precisió subpíxel
    centre_.y += dy;
@@ -107,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,
--- a/source/game/entities/bala.hpp
+++ b/source/game/entities/bala.hpp
@@ -5,43 +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, uint8_t owner_id);
-        void actualitzar(float delta_time);
-        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::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_; }
-        const Punt& get_centre() const { return centre_; }
-        uint8_t get_owner_id() const { return owner_id_; }
-        float get_grace_timer() const { return grace_timer_; }
+        [[nodiscard]] bool esta_activa() const { return esta_; }
+        [[nodiscard]] uint8_t get_owner_id() const { return owner_id_; }
+        [[nodiscard]] float get_grace_timer() const { return grace_timer_; }
        void desactivar() { esta_ = false; }

    private:
-        SDL_Renderer* renderer_;
-
-        // [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_;
+        // Membres específics de Bala (heretats: renderer_, forma_, centre_, angle_, brightness_)
        float velocitat_;
        bool esta_;
        uint8_t owner_id_;   // 0=P1, 1=P2
        float grace_timer_;  // Grace period timer (0.0 = vulnerable)
-        float brightness_;   // Factor de brillantor (0.0-1.0)

        void mou(float delta_time);
 };
--- a/source/game/entities/enemic.cpp
+++ b/source/game/entities/enemic.cpp
@@ -4,29 +4,32 @@

 #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),
-      centre_({0.0f, 0.0f}),
-      angle_(0.0f),
-      velocitat_(0.0f),
-      drotacio_(0.0f),
-      rotacio_(0.0f),
+    : Entitat(renderer),
+      velocitat_(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),
-      tracking_strength_(0.5f),        // Default tracking strength
-      timer_invulnerabilitat_(0.0f) {  // Start vulnerable
+      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
 }
@@ -37,7 +40,8 @@ void Enemic::inicialitzar(TipusEnemic tipus, const Punt* ship_pos) {

    // 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:
@@ -52,7 +56,7 @@ void Enemic::inicialitzar(TipusEnemic tipus, const Punt* ship_pos) {
            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:
@@ -61,16 +65,29 @@ void Enemic::inicialitzar(TipusEnemic tipus, const Punt* ship_pos) {
            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';
    }

    // [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,
@@ -82,7 +99,8 @@ void Enemic::inicialitzar(TipusEnemic tipus, const Punt* ship_pos) {
        bool found_safe_position = false;

        for (int attempt = 0; attempt < Defaults::Enemies::Spawn::MAX_SPAWN_ATTEMPTS; attempt++) {
-            float candidate_x, candidate_y;
+            float candidate_x;
+            float candidate_y;

            if (intent_spawn_safe(*ship_pos, candidate_x, candidate_y)) {
                centre_.x = candidate_x;
@@ -100,7 +118,7 @@ void Enemic::inicialitzar(TipusEnemic tipus, const Punt* ship_pos) {
            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" << std::endl;
+                      << Defaults::Enemies::Spawn::MAX_SPAWN_ATTEMPTS << " intents" << '\n';
        }
    } else {
        // [EXISTING] No ship position: spawn anywhere (backward compatibility)
@@ -111,18 +129,18 @@ void Enemic::inicialitzar(TipusEnemic tipus, const Punt* ship_pos) {
    }

    // 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;
-    rotacio_ = 0.0f;
+    drotacio_ = drotacio_min + ((static_cast<float>(std::rand()) / RAND_MAX) * drotacio_range);
+    rotacio_ = 0.0F;

    // Inicialitzar estat d'animació
    animacio_ = AnimacioEnemic();  // Reset to defaults
    animacio_.drotacio_base = drotacio_;
    animacio_.drotacio_objetivo = drotacio_;
-    animacio_.drotacio_t = 1.0f;  // Start without interpolating
+    animacio_.drotacio_t = 1.0F;  // Start without interpolating

    // [NEW] Inicialitzar invulnerabilitat
    timer_invulnerabilitat_ = Defaults::Enemies::Spawn::INVULNERABILITY_DURATION;  // 3.0s
@@ -135,21 +153,19 @@ void Enemic::inicialitzar(TipusEnemic tipus, const Punt* ship_pos) {
 void Enemic::actualitzar(float delta_time) {
    if (esta_) {
        // [NEW] Update invulnerability timer and brightness
-        if (timer_invulnerabilitat_ > 0.0f) {
+        if (timer_invulnerabilitat_ > 0.0F) {
            timer_invulnerabilitat_ -= delta_time;

-            if (timer_invulnerabilitat_ < 0.0f) {
-                timer_invulnerabilitat_ = 0.0f;
-            }
+            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
+            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;
+            brightness_ = START + ((END - START) * smooth_t);
        }

        // Moviment autònom
@@ -169,7 +185,7 @@ void Enemic::dibuixar() const {
        float escala = calcular_escala_actual();

        // brightness_ is already updated in actualitzar()
-        Rendering::render_shape(renderer_, forma_, centre_, rotacio_, escala, true, 1.0f, brightness_);
+        Rendering::render_shape(renderer_, forma_, centre_, rotacio_, escala, true, 1.0F, brightness_);
    }
 }

@@ -185,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;
    }
 }

@@ -195,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 dx = velocitat_efectiva * std::cos(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 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,20 +263,24 @@ 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) angle_diff += 2.0f * Constants::PI;
+            while (angle_diff > Constants::PI) {
+                angle_diff -= 2.0F * Constants::PI;
+            }
+            while (angle_diff < -Constants::PI) {
+                angle_diff += 2.0F * Constants::PI;
+            }

            // Apply tracking strength (uses member variable, defaults to 0.5)
            angle_ += angle_diff * tracking_strength_;
@@ -262,14 +289,17 @@ void Enemic::comportament_quadrat(float delta_time) {

    // Move in current direction
    float velocitat_efectiva = velocitat_ * delta_time;
-    float dy = velocitat_efectiva * std::sin(angle_ - Constants::PI / 2.0f);
-    float dx = velocitat_efectiva * std::cos(angle_ - Constants::PI / 2.0f);
+    float dy = velocitat_efectiva * std::sin(angle_ - (Constants::PI / 2.0F));
+    float dx = velocitat_efectiva * std::cos(angle_ - (Constants::PI / 2.0F));

    float new_y = centre_.y + dy;
    float new_x = centre_.x + dx;

    // Obtenir límits segurs
-    float min_x, 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,
@@ -294,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
@@ -311,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 dx = velocitat_efectiva * std::cos(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 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,
@@ -355,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 {
@@ -372,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) {
-            animacio_.drotacio_t = 1.0f;
+        if (animacio_.drotacio_t >= 1.0F) {
+            animacio_.drotacio_t = 1.0F;
            animacio_.drotacio_base = animacio_.drotacio_objetivo;  // Reached target
            drotacio_ = animacio_.drotacio_base;
        } else {
            // Smoothstep interpolation: t² * (3 - 2t)
            float t = animacio_.drotacio_t;
-            float smooth_t = t * t * (3.0f - 2.0f * t);
+            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
@@ -419,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;

@@ -433,27 +466,27 @@ 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;

    // [NEW] Invulnerability LERP prioritza sobre palpitació
-    if (timer_invulnerabilitat_ > 0.0f) {
+    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
+        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);
+        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;
+        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);
@@ -472,13 +505,14 @@ float Enemic::get_base_velocity() const {
            return Defaults::Enemies::Quadrat::VELOCITAT;
        case TipusEnemic::MOLINILLO:
            return Defaults::Enemies::Molinillo::VELOCITAT;
+        default:
+            return Defaults::Enemies::Pentagon::VELOCITAT;  // Fallback segur
    }
-    return 0.0f;
 }

 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_;
+    return animacio_.drotacio_base != 0.0F ? animacio_.drotacio_base : drotacio_;
 }

 void Enemic::set_tracking_strength(float strength) {
@@ -491,7 +525,10 @@ void Enemic::set_tracking_strength(float 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, 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,
@@ -507,7 +544,7 @@ bool Enemic::intent_spawn_safe(const Punt& ship_pos, float& out_x, float& out_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);
+    float distancia = std::sqrt((dx * dx) + (dy * dy));

    // Return true if position is safe (>= 36px from ship)
    return distancia >= Defaults::Enemies::Spawn::SAFETY_DISTANCE;
--- a/source/game/entities/enemic.hpp
+++ b/source/game/entities/enemic.hpp
@@ -5,9 +5,11 @@
 #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"

@@ -22,48 +24,56 @@ 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_frequencia = 2.0f;     // Hz (cycles per second)
-        float palpitacio_amplitud = 0.15f;      // Scale variation (±15%)
-        float palpitacio_temps_restant = 0.0f;  // Time remaining (seconds)
+        float palpitacio_fase = 0.0F;           // Phase in cycle (0.0-2π)
+        float palpitacio_frequencia = 2.0F;     // Hz (cycles per second)
+        float palpitacio_amplitud = 0.15F;      // Scale variation (±15%)
+        float palpitacio_temps_restant = 0.0F;  // Time remaining (seconds)

        // Rotation acceleration (long-term spin modulation)
-        float drotacio_base = 0.0f;      // Base rotation speed (rad/s)
-        float drotacio_objetivo = 0.0f;  // Target rotation speed (rad/s)
-        float drotacio_t = 0.0f;         // Interpolation progress (0.0-1.0)
-        float drotacio_duracio = 0.0f;   // Duration of transition (seconds)
+        float drotacio_base = 0.0F;      // Base rotation speed (rad/s)
+        float drotacio_objetivo = 0.0F;  // Target rotation speed (rad/s)
+        float drotacio_t = 0.0F;         // Interpolation progress (0.0-1.0)
+        float drotacio_duracio = 0.0F;   // Duration of transition (seconds)
 };

-class Enemic {
+class Enemic : public Entities::Entitat {
    public:
        Enemic()
-            : renderer_(nullptr) {}
+            : Entitat(nullptr) {}
        Enemic(SDL_Renderer* renderer);

-        void inicialitzar(TipusEnemic tipus = TipusEnemic::PENTAGON, const Punt* ship_pos = nullptr);
-        void actualitzar(float delta_time);
-        void dibuixar() const;
+        void inicialitzar() override { inicialitzar(TipusEnemic::PENTAGON, nullptr); }
+        void inicialitzar(TipusEnemic tipus, const Punt* ship_pos = nullptr);
+        void actualitzar(float delta_time) override;
+        void dibuixar() const override;
+
+        // Override: Interfície d'Entitat
+        [[nodiscard]] bool esta_actiu() const override { return esta_; }
+
+        // Override: Interfície de col·lisió
+        [[nodiscard]] float get_collision_radius() const override {
+            return Defaults::Entities::ENEMY_RADIUS;
+        }
+        [[nodiscard]] bool es_collidable() const override {
+            return esta_ && timer_invulnerabilitat_ <= 0.0F;
+        }

        // Getters (API pública sense canvis)
-        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; }
-        float get_brightness() const { return brightness_; }
-        float get_drotacio() const { return drotacio_; }
-        Punt get_velocitat_vector() const {
+        [[nodiscard]] float get_drotacio() const { return drotacio_; }
+        [[nodiscard]] Punt get_velocitat_vector() const {
            return {
-                velocitat_ * std::cos(angle_ - Constants::PI / 2.0f),
-                velocitat_ * std::sin(angle_ - Constants::PI / 2.0f)};
+                .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)
-        float get_base_velocity() const;
-        float get_base_rotation() const;
-        TipusEnemic get_tipus() const { return tipus_; }
+        [[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; }
@@ -74,23 +84,15 @@ class Enemic {
        void set_tracking_strength(float strength);

        // [NEW] Invulnerability queries
-        bool es_invulnerable() const { return timer_invulnerabilitat_ > 0.0f; }
-        float get_temps_invulnerabilitat() const { return timer_invulnerabilitat_; }
+        [[nodiscard]] bool es_invulnerable() const { return timer_invulnerabilitat_ > 0.0F; }
+        [[nodiscard]] float get_temps_invulnerabilitat() const { return timer_invulnerabilitat_; }

    private:
-        SDL_Renderer* renderer_;
-
-        // [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
+        // Membres específics d'Enemic (heretats: renderer_, forma_, centre_, angle_, brightness_)
        float velocitat_;
        float drotacio_;  // Delta rotació visual (rad/s)
        float rotacio_;   // Rotació visual acumulada
        bool esta_;
-        float brightness_;  // Factor de brillantor (0.0-1.0)

        // [NEW] Enemy type and configuration
        TipusEnemic tipus_;
@@ -116,6 +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);
 };
--- a/source/game/entities/nau.cpp
+++ b/source/game/entities/nau.cpp
@@ -6,28 +6,33 @@

 #include <SDL3/SDL.h>

+#include <algorithm>
 #include <cmath>
+#include <cstdint>
 #include <iostream>

 #include "core/defaults.hpp"
+#include "core/entities/entitat.hpp"
 #include "core/graphics/shape_loader.hpp"
 #include "core/input/input.hpp"
+#include "core/input/input_types.hpp"
 #include "core/rendering/shape_renderer.hpp"
+#include "core/types.hpp"
 #include "game/constants.hpp"

 Nau::Nau(SDL_Renderer* renderer, const char* shape_file)
-    : renderer_(renderer),
-      centre_({0.0f, 0.0f}),
-      angle_(0.0f),
-      velocitat_(0.0f),
+    : Entitat(renderer),
+      velocitat_(0.0F),
      esta_tocada_(false),
-      brightness_(Defaults::Brightness::NAU),
-      invulnerable_timer_(0.0f) {
+      invulnerable_timer_(0.0F) {
+    // [NUEVO] Brightness específic per naus
+    brightness_ = Defaults::Brightness::NAU;
+
    // [NUEVO] Carregar forma compartida des de fitxer
    forma_ = Graphics::ShapeLoader::load(shape_file);

    if (!forma_ || !forma_->es_valida()) {
-        std::cerr << "[Nau] Error: no s'ha pogut carregar " << shape_file << std::endl;
+        std::cerr << "[Nau] Error: no s'ha pogut carregar " << shape_file << '\n';
    }
 }

@@ -40,26 +45,27 @@ void Nau::inicialitzar(const Punt* spawn_point, bool activar_invulnerabilitat) {
    // 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;
-    velocitat_ = 0.0f;
+    angle_ = 0.0F;
+    velocitat_ = 0.0F;

    // Activar invulnerabilidad solo si es respawn
    if (activar_invulnerabilitat) {
        invulnerable_timer_ = Defaults::Ship::INVULNERABILITY_DURATION;
    } else {
-        invulnerable_timer_ = 0.0f;
+        invulnerable_timer_ = 0.0F;
    }

    esta_tocada_ = false;
@@ -69,8 +75,9 @@ 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;
+    }

    auto* input = Input::get();

@@ -88,9 +95,7 @@ void Nau::processar_input(float delta_time, uint8_t player_id) {
        if (input->checkActionPlayer1(InputAction::THRUST, Input::ALLOW_REPEAT)) {
            if (velocitat_ < Defaults::Physics::MAX_VELOCITY) {
                velocitat_ += Defaults::Physics::ACCELERATION * delta_time;
-                if (velocitat_ > Defaults::Physics::MAX_VELOCITY) {
-                    velocitat_ = Defaults::Physics::MAX_VELOCITY;
-                }
+                velocitat_ = std::min(velocitat_, Defaults::Physics::MAX_VELOCITY);
            }
        }
    } else {
@@ -106,9 +111,7 @@ void Nau::processar_input(float delta_time, uint8_t player_id) {
        if (input->checkActionPlayer2(InputAction::THRUST, Input::ALLOW_REPEAT)) {
            if (velocitat_ < Defaults::Physics::MAX_VELOCITY) {
                velocitat_ += Defaults::Physics::ACCELERATION * delta_time;
-                if (velocitat_ > Defaults::Physics::MAX_VELOCITY) {
-                    velocitat_ = Defaults::Physics::MAX_VELOCITY;
-                }
+                velocitat_ = std::min(velocitat_, Defaults::Physics::MAX_VELOCITY);
            }
        }
    }
@@ -116,15 +119,14 @@ void Nau::processar_input(float delta_time, uint8_t player_id) {

 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) {
+    if (invulnerable_timer_ > 0.0F) {
        invulnerable_timer_ -= delta_time;
-        if (invulnerable_timer_ < 0.0f) {
-            invulnerable_timer_ = 0.0f;
-        }
+        invulnerable_timer_ = std::max(invulnerable_timer_, 0.0F);
    }

    // Aplicar física (moviment + fricció)
@@ -133,8 +135,9 @@ 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;
+    }

    // Si invulnerable, parpadear (toggle on/off)
    if (es_invulnerable()) {
@@ -149,8 +152,9 @@ void Nau::dibuixar() const {
        }
    }

-    if (!forma_)
+    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
@@ -160,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 escala = 1.0f + (velocitat_visual / 12.0f);
+    float velocitat_visual = velocitat_ / 33.33F;
+    float escala = 1.0F + (velocitat_visual / 12.0F);

-    Rendering::render_shape(renderer_, forma_, centre_, angle_, escala, true, 1.0f, brightness_);
+    Rendering::render_shape(renderer_, forma_, centre_, angle_, escala, true, 1.0F, brightness_);
 }

 void Nau::aplicar_fisica(float delta_time) {
@@ -174,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,
@@ -199,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_ = 0.0f;
-        }
+        velocitat_ = std::max(velocitat_, 0.0F);
    }
 }
--- a/source/game/entities/nau.hpp
+++ b/source/game/entities/nau.hpp
@@ -5,35 +5,45 @@
 #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, const char* shape_file = "ship.shp");

-        void inicialitzar(const Punt* spawn_point = nullptr, bool activar_invulnerabilitat = false);
+        void inicialitzar() override { inicialitzar(nullptr, false); }
+        void inicialitzar(const Punt* spawn_point, bool activar_invulnerabilitat = false);
        void processar_input(float delta_time, uint8_t player_id);
-        void actualitzar(float delta_time);
-        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_; }
-        float get_angle() const { return angle_; }
-        bool esta_viva() const { return !esta_tocada_; }
-        bool esta_tocada() const { return esta_tocada_; }
-        bool es_invulnerable() const { return invulnerable_timer_ > 0.0f; }
-        const std::shared_ptr<Graphics::Shape>& get_forma() const { return forma_; }
-        float get_brightness() const { return brightness_; }
-        Punt get_velocitat_vector() const {
+        [[nodiscard]] bool esta_viva() const { return !esta_tocada_; }
+        [[nodiscard]] bool esta_tocada() const { return esta_tocada_; }
+        [[nodiscard]] bool es_invulnerable() const { return invulnerable_timer_ > 0.0F; }
+        [[nodiscard]] Punt get_velocitat_vector() const {
            return {
-                velocitat_ * std::cos(angle_ - Constants::PI / 2.0f),
-                velocitat_ * std::sin(angle_ - Constants::PI / 2.0f)};
+                .x = velocitat_ * std::cos(angle_ - (Constants::PI / 2.0F)),
+                .y = velocitat_ * std::sin(angle_ - (Constants::PI / 2.0F))};
        }

        // Setters
@@ -43,18 +53,9 @@ class Nau {
        void marcar_tocada() { esta_tocada_ = true; }

    private:
-        SDL_Renderer* renderer_;
-
-        // [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ó
+        // Membres específics de Nau (heretats: renderer_, forma_, centre_, angle_, brightness_)
        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);
--- a/source/game/escenes/escena_joc.cpp
+++ b/source/game/escenes/escena_joc.cpp
@@ -4,6 +4,7 @@

 #include "escena_joc.hpp"

+#include <algorithm>
 #include <cmath>
 #include <cstdlib>
 #include <ctime>
@@ -11,9 +12,11 @@
 #include <vector>

 #include "core/audio/audio.hpp"
+#include "core/entities/entitat.hpp"
 #include "core/input/input.hpp"
 #include "core/input/mouse.hpp"
 #include "core/math/easing.hpp"
+#include "core/physics/collision.hpp"
 #include "core/rendering/line_renderer.hpp"
 #include "core/system/context_escenes.hpp"
 #include "core/system/global_events.hpp"
@@ -39,7 +42,7 @@ EscenaJoc::EscenaJoc(SDLManager& sdl, ContextEscenes& context)
              << (config_partida_.jugador1_actiu ? "ACTIU" : "INACTIU")
              << ", P2: "
              << (config_partida_.jugador2_actiu ? "ACTIU" : "INACTIU")
-              << std::endl;
+              << '\n';

    // Consumir opcions (preparació per MODE_DEMO futur)
    auto opcio = context_.consumir_opcio();
@@ -72,13 +75,11 @@ void EscenaJoc::executar() {
    while (GestorEscenes::actual == Escena::JOC) {
        // 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 = 0.05f;
-        }
+        delta_time = std::min(delta_time, 0.05F);

        // Actualitzar comptador de FPS
        sdl_.updateFPS(delta_time);
@@ -134,7 +135,7 @@ void EscenaJoc::inicialitzar() {
    if (!stage_config_) {
        stage_config_ = StageSystem::StageLoader::carregar("data/stages/stages.yaml");
        if (!stage_config_) {
-            std::cerr << "[EscenaJoc] Error: no s'ha pogut carregar stages.yaml" << std::endl;
+            std::cerr << "[EscenaJoc] Error: no s'ha pogut carregar stages.yaml" << '\n';
            // Continue without stage system (will crash, but helps debugging)
        }
    }
@@ -147,17 +148,17 @@ void EscenaJoc::inicialitzar() {
    stage_manager_->get_spawn_controller().set_ship_position(&naus_[0].get_centre());

    // Inicialitzar timers de muerte per jugador
-    itocado_per_jugador_[0] = 0.0f;
-    itocado_per_jugador_[1] = 0.0f;
+    itocado_per_jugador_[0] = 0.0F;
+    itocado_per_jugador_[1] = 0.0F;

    // Initialize lives and game over state (independent lives per player)
    vides_per_jugador_[0] = Defaults::Game::STARTING_LIVES;
    vides_per_jugador_[1] = Defaults::Game::STARTING_LIVES;
    estat_game_over_ = EstatGameOver::NONE;
    continue_counter_ = 0;
-    continue_tick_timer_ = 0.0f;
+    continue_tick_timer_ = 0.0F;
    continues_usados_ = 0;
-    game_over_timer_ = 0.0f;
+    game_over_timer_ = 0.0F;

    // Initialize scores (separate per player)
    puntuacio_per_jugador_[0] = 0;
@@ -181,7 +182,7 @@ void EscenaJoc::inicialitzar() {
        } else {
            // Jugador inactiu: marcar com a mort permanent
            naus_[i].marcar_tocada();
-            itocado_per_jugador_[i] = 999.0f;  // Valor sentinella (permanent inactiu)
+            itocado_per_jugador_[i] = 999.0F;  // Valor sentinella (permanent inactiu)
            vides_per_jugador_[i] = 0;         // Sense vides
            std::cout << "[EscenaJoc] Jugador " << (i + 1) << " inactiu\n";
        }
@@ -231,10 +232,10 @@ void EscenaJoc::actualitzar(float delta_time) {
        if (stage_manager_->get_estat() == StageSystem::EstatStage::PLAYING) {
            // Check if at least one player is alive and playing (game in progress)
            bool algun_jugador_viu = false;
-            if (config_partida_.jugador1_actiu && itocado_per_jugador_[0] != 999.0f) {
+            if (config_partida_.jugador1_actiu && itocado_per_jugador_[0] != 999.0F) {
                algun_jugador_viu = true;
            }
-            if (config_partida_.jugador2_actiu && itocado_per_jugador_[1] != 999.0f) {
+            if (config_partida_.jugador2_actiu && itocado_per_jugador_[1] != 999.0F) {
                algun_jugador_viu = true;
            }

@@ -242,7 +243,7 @@ void EscenaJoc::actualitzar(float delta_time) {
            if (algun_jugador_viu) {
                // P2 can join if not currently playing (never joined OR dead without lives)
                bool p2_no_juga = !config_partida_.jugador2_actiu ||  // Never joined
-                    itocado_per_jugador_[1] == 999.0f;                // Dead without lives
+                    itocado_per_jugador_[1] == 999.0F;                // Dead without lives

                if (p2_no_juga) {
                    if (input->checkActionPlayer2(InputAction::START, Input::DO_NOT_ALLOW_REPEAT)) {
@@ -252,7 +253,7 @@ void EscenaJoc::actualitzar(float delta_time) {

                // P1 can join if not currently playing (never joined OR dead without lives)
                bool p1_no_juga = !config_partida_.jugador1_actiu ||  // Never joined
-                    itocado_per_jugador_[0] == 999.0f;                // Dead without lives
+                    itocado_per_jugador_[0] == 999.0F;                // Dead without lives

                if (p1_no_juga) {
                    if (input->checkActionPlayer1(InputAction::START, Input::DO_NOT_ALLOW_REPEAT)) {
@@ -285,7 +286,7 @@ void EscenaJoc::actualitzar(float delta_time) {
        // Game over: only update timer, enemies, bullets, and debris
        game_over_timer_ -= delta_time;

-        if (game_over_timer_ <= 0.0f) {
+        if (game_over_timer_ <= 0.0F) {
            // Aturar música de joc abans de tornar al títol
            Audio::get()->stopMusic();
            // Transició a pantalla de títol
@@ -311,7 +312,7 @@ void EscenaJoc::actualitzar(float delta_time) {
    // Check death sequence state for BOTH players
    bool algun_jugador_mort = false;
    for (uint8_t i = 0; i < 2; i++) {
-        if (itocado_per_jugador_[i] > 0.0f && itocado_per_jugador_[i] < 999.0f) {
+        if (itocado_per_jugador_[i] > 0.0F && itocado_per_jugador_[i] < 999.0F) {
            algun_jugador_mort = true;
            // Death sequence active: update timer
            itocado_per_jugador_[i] += delta_time;
@@ -327,11 +328,11 @@ void EscenaJoc::actualitzar(float delta_time) {
                    // Respawn ship en spawn position con invulnerabilidad
                    Punt spawn_pos = obtenir_punt_spawn(i);
                    naus_[i].inicialitzar(&spawn_pos, true);
-                    itocado_per_jugador_[i] = 0.0f;
+                    itocado_per_jugador_[i] = 0.0F;
                } else {
                    // Player is permanently dead (out of lives)
                    // Set sentinel value to prevent re-entering this block
-                    itocado_per_jugador_[i] = 999.0f;
+                    itocado_per_jugador_[i] = 999.0F;

                    // Check if ALL ACTIVE players are dead (trigger continue screen)
                    bool p1_dead = !config_partida_.jugador1_actiu || vides_per_jugador_[0] <= 0;
@@ -380,8 +381,8 @@ void EscenaJoc::actualitzar(float delta_time) {
            }

            // Calcular global progress (0.0 al inicio → 1.0 al final)
-            float global_progress = 1.0f - (stage_manager_->get_timer_transicio() / Defaults::Game::INIT_HUD_DURATION);
-            global_progress = std::min(1.0f, global_progress);
+            float global_progress = 1.0F - (stage_manager_->get_timer_transicio() / Defaults::Game::INIT_HUD_DURATION);
+            global_progress = std::min(1.0F, global_progress);

            // [NEW] Calcular progress independiente para cada nave
            float ship1_progress = calcular_progress_rango(
@@ -395,12 +396,12 @@ void EscenaJoc::actualitzar(float delta_time) {
                Defaults::Game::INIT_HUD_SHIP2_RATIO_END);

            // [MODIFICAT] Animar AMBAS naus con sus progress respectivos
-            if (config_partida_.jugador1_actiu && ship1_progress < 1.0f) {
+            if (config_partida_.jugador1_actiu && ship1_progress < 1.0F) {
                Punt pos_p1 = calcular_posicio_nau_init_hud(ship1_progress, 0);
                naus_[0].set_centre(pos_p1);
            }

-            if (config_partida_.jugador2_actiu && ship2_progress < 1.0f) {
+            if (config_partida_.jugador2_actiu && ship2_progress < 1.0F) {
                Punt pos_p2 = calcular_posicio_nau_init_hud(ship2_progress, 1);
                naus_[1].set_centre(pos_p2);
            }
@@ -415,7 +416,7 @@ void EscenaJoc::actualitzar(float delta_time) {
            // [DEBUG] Log entrada a LEVEL_START
            static bool first_entry = true;
            if (first_entry) {
-                std::cout << "[LEVEL_START] ENTERED with P1 pos.y=" << naus_[0].get_centre().y << std::endl;
+                std::cout << "[LEVEL_START] ENTERED with P1 pos.y=" << naus_[0].get_centre().y << '\n';
                first_entry = false;
            }

@@ -425,7 +426,7 @@ void EscenaJoc::actualitzar(float delta_time) {
            // [NEW] Allow both ships movement and shooting during intro
            for (uint8_t i = 0; i < 2; i++) {
                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0f) {  // Only active, alive players
+                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {  // Only active, alive players
                    naus_[i].processar_input(delta_time, i);
                    naus_[i].actualitzar(delta_time);
                }
@@ -443,11 +444,11 @@ void EscenaJoc::actualitzar(float delta_time) {

        case StageSystem::EstatStage::PLAYING: {
            // [NEW] Update stage manager (spawns enemies, pause if BOTH dead)
-            bool pausar_spawn = (itocado_per_jugador_[0] > 0.0f && itocado_per_jugador_[1] > 0.0f);
+            bool pausar_spawn = (itocado_per_jugador_[0] > 0.0F && itocado_per_jugador_[1] > 0.0F);
            stage_manager_->get_spawn_controller().actualitzar(delta_time, orni_, pausar_spawn);

            // [NEW] Check stage completion (only when at least one player alive)
-            bool algun_jugador_viu = (itocado_per_jugador_[0] == 0.0f || itocado_per_jugador_[1] == 0.0f);
+            bool algun_jugador_viu = (itocado_per_jugador_[0] == 0.0F || itocado_per_jugador_[1] == 0.0F);
            if (algun_jugador_viu) {
                auto& spawn_ctrl = stage_manager_->get_spawn_controller();
                if (spawn_ctrl.tots_enemics_destruits(orni_)) {
@@ -460,7 +461,7 @@ void EscenaJoc::actualitzar(float delta_time) {
            // [EXISTING] Normal gameplay - update active players
            for (uint8_t i = 0; i < 2; i++) {
                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0f) {  // Only active, alive players
+                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {  // Only active, alive players
                    naus_[i].processar_input(delta_time, i);
                    naus_[i].actualitzar(delta_time);
                }
@@ -489,7 +490,7 @@ void EscenaJoc::actualitzar(float delta_time) {
            // [NEW] Allow both ships movement and shooting during outro
            for (uint8_t i = 0; i < 2; i++) {
                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0f) {  // Only active, alive players
+                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {  // Only active, alive players
                    naus_[i].processar_input(delta_time, i);
                    naus_[i].actualitzar(delta_time);
                }
@@ -553,10 +554,10 @@ void EscenaJoc::dibuixar() {

        // Calcular centre de l'àrea de joc usant constants
        const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
-        float centre_x = play_area.x + play_area.w / 2.0f;
-        float centre_y = play_area.y + play_area.h / 2.0f;
+        float centre_x = play_area.x + (play_area.w / 2.0F);
+        float centre_y = play_area.y + (play_area.h / 2.0F);

-        text_.render_centered(game_over_text, {centre_x, centre_y}, escala, spacing);
+        text_.render_centered(game_over_text, {.x = centre_x, .y = centre_y}, escala, spacing);

        dibuixar_marcador();
        return;
@@ -570,7 +571,7 @@ void EscenaJoc::dibuixar() {
            // Calcular progrés de cada animació independent
            float timer = stage_manager_->get_timer_transicio();
            float total_time = Defaults::Game::INIT_HUD_DURATION;
-            float global_progress = 1.0f - (timer / total_time);
+            float global_progress = 1.0F - (timer / total_time);

            // [NEW] Calcular progress independiente para cada elemento
            float rect_progress = calcular_progress_rango(
@@ -594,7 +595,7 @@ void EscenaJoc::dibuixar() {
                Defaults::Game::INIT_HUD_SHIP2_RATIO_END);

            // Dibuixar elements animats
-            if (rect_progress > 0.0f) {
+            if (rect_progress > 0.0F) {
                // [NOU] Reproduir so quan comença l'animació del rectangle
                if (!init_hud_rect_sound_played_) {
                    Audio::get()->playSound(Defaults::Sound::INIT_HUD, Audio::Group::GAME);
@@ -604,16 +605,16 @@ void EscenaJoc::dibuixar() {
                dibuixar_marges_animat(rect_progress);
            }

-            if (score_progress > 0.0f) {
+            if (score_progress > 0.0F) {
                dibuixar_marcador_animat(score_progress);
            }

            // [MODIFICAT] Dibuixar naus amb progress independent
-            if (ship1_progress > 0.0f && config_partida_.jugador1_actiu && !naus_[0].esta_tocada()) {
+            if (ship1_progress > 0.0F && config_partida_.jugador1_actiu && !naus_[0].esta_tocada()) {
                naus_[0].dibuixar();
            }

-            if (ship2_progress > 0.0f && config_partida_.jugador2_actiu && !naus_[1].esta_tocada()) {
+            if (ship2_progress > 0.0F && config_partida_.jugador2_actiu && !naus_[1].esta_tocada()) {
                naus_[1].dibuixar();
            }

@@ -625,7 +626,7 @@ void EscenaJoc::dibuixar() {
            // [NEW] Draw both ships if active and alive
            for (uint8_t i = 0; i < 2; i++) {
                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0f) {
+                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {
                    naus_[i].dibuixar();
                }
            }
@@ -650,7 +651,7 @@ void EscenaJoc::dibuixar() {
            // [EXISTING] Normal rendering - active ships
            for (uint8_t i = 0; i < 2; i++) {
                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0f) {
+                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {
                    naus_[i].dibuixar();
                }
            }
@@ -673,7 +674,7 @@ void EscenaJoc::dibuixar() {
            // [NEW] Draw both ships if active and alive
            for (uint8_t i = 0; i < 2; i++) {
                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0f) {
+                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {
                    naus_[i].dibuixar();
                }
            }
@@ -700,7 +701,7 @@ void EscenaJoc::tocado(uint8_t player_id) {
    // Phase 2: Animation (0 < itocado_ < 3.0s) - debris animation
    // Phase 3: Respawn or game over (itocado_ >= 3.0s) - handled in actualitzar()

-    if (itocado_per_jugador_[player_id] == 0.0f) {
+    if (itocado_per_jugador_[player_id] == 0.0F) {
        // *** PHASE 1: TRIGGER DEATH ***

        // Mark ship as dead (stops rendering and input)
@@ -711,23 +712,23 @@ void EscenaJoc::tocado(uint8_t player_id) {
        float ship_angle = naus_[player_id].get_angle();
        Punt vel_nau = naus_[player_id].get_velocitat_vector();
        // Reduir a 80% la velocitat heretada per la nau (més realista)
-        Punt vel_nau_80 = {vel_nau.x * 0.8f, vel_nau.y * 0.8f};
+        Punt vel_nau_80 = {.x = vel_nau.x * 0.8F, .y = vel_nau.y * 0.8F};

        debris_manager_.explotar(
            naus_[player_id].get_forma(),               // Ship shape (3 lines)
            ship_pos,                                   // Center position
            ship_angle,                                 // Ship orientation
-            1.0f,                                       // Normal scale
+            1.0F,                                       // Normal scale
            Defaults::Physics::Debris::VELOCITAT_BASE,  // 80 px/s
            naus_[player_id].get_brightness(),          // Heredar brightness
            vel_nau_80,                                 // Heredar 80% velocitat
-            0.0f,                                       // Nave: trayectorias rectas (sin drotacio)
-            0.0f,                                       // Sin herencia visual (rotación aleatoria)
+            0.0F,                                       // Nave: trayectorias rectas (sin drotacio)
+            0.0F,                                       // Sin herencia visual (rotación aleatoria)
            Defaults::Sound::EXPLOSION2                 // Sonido alternativo para la explosión
        );

        // Start death timer (non-zero to avoid re-triggering)
-        itocado_per_jugador_[player_id] = 0.001f;
+        itocado_per_jugador_[player_id] = 0.001F;
    }
    // Phase 2 is automatic (debris updates in actualitzar())
    // Phase 3 is handled in actualitzar() when itocado_per_jugador_ >= DEATH_DURATION
@@ -755,16 +756,16 @@ void EscenaJoc::dibuixar_marcador() {
    std::string text = construir_marcador();

    // Paràmetres de renderització
-    const float escala = 0.85f;
-    const float spacing = 0.0f;
+    const float escala = 0.85F;
+    const float spacing = 0.0F;

    // Calcular centre de la zona del marcador
    const SDL_FRect& scoreboard = Defaults::Zones::SCOREBOARD;
-    float centre_x = scoreboard.w / 2.0f;
-    float centre_y = scoreboard.y + scoreboard.h / 2.0f;
+    float centre_x = scoreboard.w / 2.0F;
+    float centre_y = scoreboard.y + (scoreboard.h / 2.0F);

    // Renderitzar centrat
-    text_.render_centered(text, {centre_x, centre_y}, escala, spacing);
+    text_.render_centered(text, {.x = centre_x, .y = centre_y}, escala, spacing);
 }

 void EscenaJoc::dibuixar_marges_animat(float progress) const {
@@ -784,28 +785,28 @@ void EscenaJoc::dibuixar_marges_animat(float progress) const {
    int cx = (x1 + x2) / 2;

    // Dividir en 3 fases de 33% cada una
-    constexpr float PHASE_1_END = 0.33f;
-    constexpr float PHASE_2_END = 0.66f;
+    constexpr float PHASE_1_END = 0.33F;
+    constexpr float PHASE_2_END = 0.66F;

    // --- FASE 1: Línies horitzontals superiors (0-33%) ---
-    if (eased_progress > 0.0f) {
-        float phase1_progress = std::min(eased_progress / PHASE_1_END, 1.0f);
+    if (eased_progress > 0.0F) {
+        float phase1_progress = std::min(eased_progress / PHASE_1_END, 1.0F);

        // Línia esquerra: creix des del centre cap a l'esquerra
-        int x1_phase1 = static_cast<int>(cx - (cx - x1) * phase1_progress);
+        int x1_phase1 = static_cast<int>(cx - ((cx - x1) * phase1_progress));
        Rendering::linea(sdl_.obte_renderer(), cx, y1, x1_phase1, y1, true);

        // Línia dreta: creix des del centre cap a la dreta
-        int x2_phase1 = static_cast<int>(cx + (x2 - cx) * phase1_progress);
+        int x2_phase1 = static_cast<int>(cx + ((x2 - cx) * phase1_progress));
        Rendering::linea(sdl_.obte_renderer(), cx, y1, x2_phase1, y1, true);
    }

    // --- FASE 2: Línies verticals laterals (33-66%) ---
    if (eased_progress > PHASE_1_END) {
-        float phase2_progress = std::min((eased_progress - PHASE_1_END) / (PHASE_2_END - PHASE_1_END), 1.0f);
+        float phase2_progress = std::min((eased_progress - PHASE_1_END) / (PHASE_2_END - PHASE_1_END), 1.0F);

        // Línia esquerra: creix des de dalt cap a baix
-        int y2_phase2 = static_cast<int>(y1 + (y2 - y1) * phase2_progress);
+        int y2_phase2 = static_cast<int>(y1 + ((y2 - y1) * phase2_progress));
        Rendering::linea(sdl_.obte_renderer(), x1, y1, x1, y2_phase2, true);

        // Línia dreta: creix des de dalt cap a baix
@@ -814,14 +815,14 @@ void EscenaJoc::dibuixar_marges_animat(float progress) const {

    // --- FASE 3: Línies horitzontals inferiors (66-100%) ---
    if (eased_progress > PHASE_2_END) {
-        float phase3_progress = (eased_progress - PHASE_2_END) / (1.0f - PHASE_2_END);
+        float phase3_progress = (eased_progress - PHASE_2_END) / (1.0F - PHASE_2_END);

        // Línia esquerra: creix des de l'esquerra cap al centre
-        int x_left_phase3 = static_cast<int>(x1 + (cx - x1) * phase3_progress);
+        int x_left_phase3 = static_cast<int>(x1 + ((cx - x1) * phase3_progress));
        Rendering::linea(sdl_.obte_renderer(), x1, y2, x_left_phase3, y2, true);

        // Línia dreta: creix des de la dreta cap al centre
-        int x_right_phase3 = static_cast<int>(x2 - (x2 - cx) * phase3_progress);
+        int x_right_phase3 = static_cast<int>(x2 - ((x2 - cx) * phase3_progress));
        Rendering::linea(sdl_.obte_renderer(), x2, y2, x_right_phase3, y2, true);
    }
 }
@@ -836,22 +837,22 @@ void EscenaJoc::dibuixar_marcador_animat(float progress) {
    std::string text = construir_marcador();

    // Paràmetres
-    const float escala = 0.85f;
-    const float spacing = 0.0f;
+    const float escala = 0.85F;
+    const float spacing = 0.0F;

    // Calcular centre de la zona del marcador
    const SDL_FRect& scoreboard = Defaults::Zones::SCOREBOARD;
-    float centre_x = scoreboard.w / 2.0f;
-    float centre_y_final = scoreboard.y + scoreboard.h / 2.0f;
+    float centre_x = scoreboard.w / 2.0F;
+    float centre_y_final = scoreboard.y + (scoreboard.h / 2.0F);

    // Posició Y inicial (offscreen, sota de la pantalla)
-    float centre_y_inicial = static_cast<float>(Defaults::Game::HEIGHT);
+    auto centre_y_inicial = static_cast<float>(Defaults::Game::HEIGHT);

    // Interpolació amb easing
-    float centre_y_animada = centre_y_inicial + (centre_y_final - centre_y_inicial) * eased_progress;
+    float centre_y_animada = centre_y_inicial + ((centre_y_final - centre_y_inicial) * eased_progress);

    // Renderitzar centrat en posició animada
-    text_.render_centered(text, {centre_x, centre_y_animada}, escala, spacing);
+    text_.render_centered(text, {.x = centre_x, .y = centre_y_animada}, escala, spacing);
 }

 Punt EscenaJoc::calcular_posicio_nau_init_hud(float progress, uint8_t player_id) const {
@@ -869,13 +870,13 @@ Punt EscenaJoc::calcular_posicio_nau_init_hud(float progress, uint8_t player_id)
    float y_final = spawn_final.y;

    // Y inicial: offscreen, 50px sota la zona de joc
-    float y_inicial = zona.y + zona.h + 50.0f;
+    float y_inicial = zona.y + zona.h + 50.0F;

    // X no canvia (destí segons player_id)
    // Y interpola amb easing
-    float y_animada = y_inicial + (y_final - y_inicial) * eased_progress;
+    float y_animada = y_inicial + ((y_final - y_inicial) * eased_progress);

-    return {x_final, y_animada};
+    return {.x = x_final, .y = y_animada};
 }

 float EscenaJoc::calcular_progress_rango(float global_progress, float ratio_init, float ratio_end) const {
@@ -888,15 +889,15 @@ float EscenaJoc::calcular_progress_rango(float global_progress, float ratio_init

    // Validación de parámetros (evita división por cero)
    if (ratio_init >= ratio_end) {
-        return (global_progress >= ratio_end) ? 1.0f : 0.0f;
+        return (global_progress >= ratio_end) ? 1.0F : 0.0F;
    }

    if (global_progress < ratio_init) {
-        return 0.0f;
+        return 0.0F;
    }

    if (global_progress > ratio_end) {
-        return 1.0f;
+        return 1.0F;
    }

    // Normalizar rango [INIT, END] a [0.0, 1.0]
@@ -943,40 +944,21 @@ std::string EscenaJoc::construir_marcador() const {
 }

 void EscenaJoc::detectar_col·lisions_bales_enemics() {
-    // Constants amplificades per hitbox més generós (115%)
-    constexpr float RADI_BALA = Defaults::Entities::BULLET_RADIUS;
-    constexpr float RADI_ENEMIC = Defaults::Entities::ENEMY_RADIUS;
-    constexpr float SUMA_RADIS = (RADI_BALA + RADI_ENEMIC) * 1.15f;  // 28.75 px
-    constexpr float SUMA_RADIS_QUADRAT = SUMA_RADIS * SUMA_RADIS;    // 826.56
+    // Amplificador per hitbox més generós (115%)
+    constexpr float AMPLIFIER = Defaults::Game::COLLISION_BULLET_ENEMY_AMPLIFIER;

    // Velocitat d'explosió reduïda per efecte suau
-    constexpr float VELOCITAT_EXPLOSIO = 80.0f;  // px/s (en lloc de 80.0f per defecte)
+    constexpr float VELOCITAT_EXPLOSIO = 80.0F;  // px/s (en lloc de 80.0f per defecte)

-    // Iterar per totes les bales actives
+    // Iterar per totes les bales i enemics
    for (auto& bala : bales_) {
-        if (!bala.esta_activa()) {
-            continue;
-        }
-
-        const Punt& pos_bala = bala.get_centre();
-
-        // Comprovar col·lisió amb tots els enemics actius
        for (auto& enemic : orni_) {
-            if (!enemic.esta_actiu()) {
-                continue;
-            }
-
-            const Punt& pos_enemic = enemic.get_centre();
-
-            // Calcular distància quadrada (evita sqrt)
-            float dx = pos_bala.x - pos_enemic.x;
-            float dy = pos_bala.y - pos_enemic.y;
-            float distancia_quadrada = dx * dx + dy * dy;
-
-            // Comprovar col·lisió
-            if (distancia_quadrada <= SUMA_RADIS_QUADRAT) {
+            // Comprovar col·lisió utilitzant la interfície genèrica
+            if (Physics::check_collision(bala, enemic, AMPLIFIER)) {
                // *** COL·LISIÓ DETECTADA ***

+                const Punt& pos_enemic = enemic.get_centre();
+
                // 1. Calculate score for enemy type
                int punts = 0;
                switch (enemic.get_tipus()) {
@@ -1006,13 +988,13 @@ void EscenaJoc::detectar_col·lisions_bales_enemics() {
                debris_manager_.explotar(
                    enemic.get_forma(),       // Forma vectorial del pentàgon
                    pos_enemic,               // Posició central
-                    0.0f,                     // Angle (enemic té rotació interna)
-                    1.0f,                     // Escala normal
+                    0.0F,                     // Angle (enemic té rotació interna)
+                    1.0F,                     // Escala normal
                    VELOCITAT_EXPLOSIO,       // 50 px/s (explosió suau)
                    enemic.get_brightness(),  // Heredar brightness
                    vel_enemic,               // Heredar velocitat
                    enemic.get_drotacio(),    // Heredar velocitat angular (trayectorias curvas)
-                    0.0f                      // Sin herencia visual (rotación aleatoria)
+                    0.0F                      // Sin herencia visual (rotación aleatoria)
                );

                // 3. Desactivar bala
@@ -1026,42 +1008,31 @@ void EscenaJoc::detectar_col·lisions_bales_enemics() {
 }

 void EscenaJoc::detectar_col·lisio_naus_enemics() {
-    // Generous collision detection (80% hitbox)
-    constexpr float RADI_NAU = Defaults::Entities::SHIP_RADIUS;
-    constexpr float RADI_ENEMIC = Defaults::Entities::ENEMY_RADIUS;
-    constexpr float SUMA_RADIS =
-        (RADI_NAU + RADI_ENEMIC) * Defaults::Game::COLLISION_SHIP_ENEMY_AMPLIFIER;
-    constexpr float SUMA_RADIS_QUADRAT = SUMA_RADIS * SUMA_RADIS;
+    // Amplificador per hitbox generós (80%)
+    constexpr float AMPLIFIER = Defaults::Game::COLLISION_SHIP_ENEMY_AMPLIFIER;

    // Check collision for BOTH players
    for (uint8_t i = 0; i < 2; i++) {
        // Skip collisions if player is dead or invulnerable
-        if (itocado_per_jugador_[i] > 0.0f) continue;
-        if (!naus_[i].esta_viva()) continue;
-        if (naus_[i].es_invulnerable()) continue;
-
-        const Punt& pos_nau = naus_[i].get_centre();
+        if (itocado_per_jugador_[i] > 0.0F) {
+            continue;
+        }
+        if (!naus_[i].esta_viva()) {
+            continue;
+        }
+        if (naus_[i].es_invulnerable()) {
+            continue;
+        }

        // Check collision with all active enemies
        for (const auto& enemic : orni_) {
-            if (!enemic.esta_actiu()) {
-                continue;
-            }
-
            // Skip collision if enemy is invulnerable
            if (enemic.es_invulnerable()) {
                continue;
            }

-            const Punt& pos_enemic = enemic.get_centre();
-
-            // Calculate squared distance (avoid sqrt)
-            float dx = static_cast<float>(pos_nau.x - pos_enemic.x);
-            float dy = static_cast<float>(pos_nau.y - pos_enemic.y);
-            float distancia_quadrada = dx * dx + dy * dy;
-
-            // Check collision
-            if (distancia_quadrada <= SUMA_RADIS_QUADRAT) {
+            // Comprovar col·lisió utilitzant la interfície genèrica
+            if (Physics::check_collision(naus_[i], enemic, AMPLIFIER)) {
                tocado(i);  // Trigger death sequence for player i
                break;      // Only one collision per player per frame
            }
@@ -1075,12 +1046,8 @@ void EscenaJoc::detectar_col·lisions_bales_jugadors() {
        return;
    }

-    // Collision constants (exact hitbox, 1.0x amplification)
-    constexpr float RADI_NAU = Defaults::Entities::SHIP_RADIUS;
-    constexpr float RADI_BALA = Defaults::Entities::BULLET_RADIUS;
-    constexpr float SUMA_RADIS = (RADI_NAU + RADI_BALA) *
-        Defaults::Game::COLLISION_BULLET_PLAYER_AMPLIFIER;         // 15.0 px
-    constexpr float SUMA_RADIS_QUADRAT = SUMA_RADIS * SUMA_RADIS;  // 225.0
+    // Amplificador per hitbox exacte (100%)
+    constexpr float AMPLIFIER = Defaults::Game::COLLISION_BULLET_PLAYER_AMPLIFIER;

    // Check all active bullets
    for (auto& bala : bales_) {
@@ -1089,34 +1056,34 @@ void EscenaJoc::detectar_col·lisions_bales_jugadors() {
        }

        // Skip bullets in grace period (prevents instant self-collision)
-        if (bala.get_grace_timer() > 0.0f) {
+        if (bala.get_grace_timer() > 0.0F) {
            continue;
        }

-        const Punt& pos_bala = bala.get_centre();
        uint8_t bullet_owner = bala.get_owner_id();

        // Check collision with BOTH players
        for (uint8_t player_id = 0; player_id < 2; player_id++) {
            // Skip if player is dead, invulnerable, or inactive
-            if (itocado_per_jugador_[player_id] > 0.0f) continue;
-            if (!naus_[player_id].esta_viva()) continue;
-            if (naus_[player_id].es_invulnerable()) continue;
+            if (itocado_per_jugador_[player_id] > 0.0F) {
+                continue;
+            }
+            if (!naus_[player_id].esta_viva()) {
+                continue;
+            }
+            if (naus_[player_id].es_invulnerable()) {
+                continue;
+            }

            // Skip inactive players
            bool jugador_actiu = (player_id == 0) ? config_partida_.jugador1_actiu
                                                  : config_partida_.jugador2_actiu;
-            if (!jugador_actiu) continue;
+            if (!jugador_actiu) {
+                continue;
+            }

-            const Punt& pos_nau = naus_[player_id].get_centre();
-
-            // Calculate squared distance (avoid sqrt)
-            float dx = pos_bala.x - pos_nau.x;
-            float dy = pos_bala.y - pos_nau.y;
-            float distancia_quadrada = dx * dx + dy * dy;
-
-            // Check collision
-            if (distancia_quadrada <= SUMA_RADIS_QUADRAT) {
+            // Comprovar col·lisió utilitzant la interfície genèrica
+            if (Physics::check_collision(bala, naus_[player_id], AMPLIFIER)) {
                // *** FRIENDLY FIRE HIT ***

                if (bullet_owner == player_id) {
@@ -1147,8 +1114,8 @@ void EscenaJoc::detectar_col·lisions_bales_jugadors() {
 // [NEW] Stage system helper methods

 void EscenaJoc::dibuixar_missatge_stage(const std::string& missatge) {
-    constexpr float escala_base = 1.0f;
-    constexpr float spacing = 2.0f;
+    constexpr float escala_base = 1.0F;
+    constexpr float spacing = 2.0F;

    const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
    const float max_width = play_area.w * Defaults::Game::STAGE_MESSAGE_MAX_WIDTH_RATIO;
@@ -1168,16 +1135,16 @@ void EscenaJoc::dibuixar_missatge_stage(const std::string& missatge) {

    // Calculate progress from timer (0.0 at start → 1.0 at end)
    float remaining_time = stage_manager_->get_timer_transicio();
-    float progress = 1.0f - (remaining_time / total_time);
+    float progress = 1.0F - (remaining_time / total_time);

    // Determine how many characters to show
    size_t visible_chars;

-    if (typing_ratio > 0.0f && progress < typing_ratio) {
+    if (typing_ratio > 0.0F && progress < typing_ratio) {
        // Typewriter phase: show partial text
        float typing_progress = progress / typing_ratio;  // Normalize to 0.0-1.0
        visible_chars = static_cast<size_t>(missatge.length() * typing_progress);
-        if (visible_chars == 0 && progress > 0.0f) {
+        if (visible_chars == 0 && progress > 0.0F) {
            visible_chars = 1;  // Show at least 1 character after first frame
        }
    } else {
@@ -1203,11 +1170,11 @@ void EscenaJoc::dibuixar_missatge_stage(const std::string& missatge) {
    float text_height = text_.get_text_height(escala);

    // Calculate position as if FULL text was there (for fixed position typewriter)
-    float x = play_area.x + (play_area.w - full_text_width) / 2.0f;
-    float y = play_area.y + (play_area.h * Defaults::Game::STAGE_MESSAGE_Y_RATIO) - (text_height / 2.0f);
+    float x = play_area.x + ((play_area.w - full_text_width) / 2.0F);
+    float y = play_area.y + (play_area.h * Defaults::Game::STAGE_MESSAGE_Y_RATIO) - (text_height / 2.0F);

    // Render only the partial message (typewriter effect)
-    Punt pos = {x, y};
+    Punt pos = {.x = x, .y = y};
    text_.render(partial_message, pos, escala, spacing);
 }

@@ -1221,7 +1188,7 @@ Punt EscenaJoc::obtenir_punt_spawn(uint8_t player_id) const {
    float x_ratio;
    if (config_partida_.es_un_jugador()) {
        // Un sol jugador: spawn al centre (50%)
-        x_ratio = 0.5f;
+        x_ratio = 0.5F;
    } else {
        // Dos jugadors: spawn a posicions separades
        x_ratio = (player_id == 0)
@@ -1230,26 +1197,30 @@ Punt EscenaJoc::obtenir_punt_spawn(uint8_t player_id) const {
    }

    return {
-        zona.x + zona.w * x_ratio,
-        zona.y + zona.h * Defaults::Game::SPAWN_Y_RATIO};
+        .x = zona.x + (zona.w * x_ratio),
+        .y = zona.y + (zona.h * Defaults::Game::SPAWN_Y_RATIO)};
 }

 void EscenaJoc::disparar_bala(uint8_t player_id) {
    // Verificar que el jugador está vivo
-    if (itocado_per_jugador_[player_id] > 0.0f) return;
-    if (!naus_[player_id].esta_viva()) return;
+    if (itocado_per_jugador_[player_id] > 0.0F) {
+        return;
+    }
+    if (!naus_[player_id].esta_viva()) {
+        return;
+    }

    // Calcular posición en la punta de la nave
    const Punt& ship_centre = naus_[player_id].get_centre();
    float ship_angle = naus_[player_id].get_angle();

-    constexpr float LOCAL_TIP_X = 0.0f;
-    constexpr float LOCAL_TIP_Y = -12.0f;
+    constexpr float LOCAL_TIP_X = 0.0F;
+    constexpr float LOCAL_TIP_Y = -12.0F;
    float cos_a = std::cos(ship_angle);
    float sin_a = std::sin(ship_angle);
-    float tip_x = LOCAL_TIP_X * cos_a - LOCAL_TIP_Y * sin_a + ship_centre.x;
-    float tip_y = LOCAL_TIP_X * sin_a + LOCAL_TIP_Y * cos_a + ship_centre.y;
-    Punt posicio_dispar = {tip_x, tip_y};
+    float tip_x = (LOCAL_TIP_X * cos_a) - (LOCAL_TIP_Y * sin_a) + ship_centre.x;
+    float tip_y = (LOCAL_TIP_X * sin_a) + (LOCAL_TIP_Y * cos_a) + ship_centre.y;
+    Punt posicio_dispar = {.x = tip_x, .y = tip_y};

    // Buscar primera bala inactiva en el pool del jugador
    int start_idx = player_id * 3;  // P1=[0,1,2], P2=[3,4,5]
@@ -1273,7 +1244,7 @@ void EscenaJoc::check_and_apply_continue_timeout() {
 void EscenaJoc::actualitzar_continue(float delta_time) {
    continue_tick_timer_ -= delta_time;

-    if (continue_tick_timer_ <= 0.0f) {
+    if (continue_tick_timer_ <= 0.0F) {
        continue_counter_--;
        continue_tick_timer_ = Defaults::Game::CONTINUE_TICK_DURATION;

@@ -1314,7 +1285,7 @@ void EscenaJoc::processar_input_continue() {
        // Reset score and lives (KEEP level and enemies!)
        puntuacio_per_jugador_[player_to_revive] = 0;
        vides_per_jugador_[player_to_revive] = Defaults::Game::STARTING_LIVES;
-        itocado_per_jugador_[player_to_revive] = 0.0f;
+        itocado_per_jugador_[player_to_revive] = 0.0F;

        // Activate player if not already
        if (player_to_revive == 0) {
@@ -1332,7 +1303,7 @@ void EscenaJoc::processar_input_continue() {
            uint8_t other_player = 1;
            puntuacio_per_jugador_[other_player] = 0;
            vides_per_jugador_[other_player] = Defaults::Game::STARTING_LIVES;
-            itocado_per_jugador_[other_player] = 0.0f;
+            itocado_per_jugador_[other_player] = 0.0F;
            config_partida_.jugador2_actiu = true;
            Punt spawn_pos2 = obtenir_punt_spawn(other_player);
            naus_[other_player].inicialitzar(&spawn_pos2, true);
@@ -1341,7 +1312,7 @@ void EscenaJoc::processar_input_continue() {
        // Resume game
        estat_game_over_ = EstatGameOver::NONE;
        continue_counter_ = 0;
-        continue_tick_timer_ = 0.0f;
+        continue_tick_timer_ = 0.0F;

        // Play continue confirmation sound
        Audio::get()->playSound(Defaults::Sound::START, Audio::Group::GAME);
@@ -1373,26 +1344,26 @@ void EscenaJoc::processar_input_continue() {

 void EscenaJoc::dibuixar_continue() {
    const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
-    constexpr float spacing = 4.0f;
+    constexpr float spacing = 4.0F;

    // "CONTINUE" text (using constants)
    const std::string continue_text = "CONTINUE";
    float escala_continue = Defaults::Game::ContinueScreen::CONTINUE_TEXT_SCALE;
    float y_ratio_continue = Defaults::Game::ContinueScreen::CONTINUE_TEXT_Y_RATIO;

-    float centre_x = play_area.x + play_area.w / 2.0f;
-    float centre_y_continue = play_area.y + play_area.h * y_ratio_continue;
+    float centre_x = play_area.x + (play_area.w / 2.0F);
+    float centre_y_continue = play_area.y + (play_area.h * y_ratio_continue);

-    text_.render_centered(continue_text, {centre_x, centre_y_continue}, escala_continue, spacing);
+    text_.render_centered(continue_text, {.x = centre_x, .y = centre_y_continue}, escala_continue, spacing);

    // Countdown number (using constants)
    const std::string counter_str = std::to_string(continue_counter_);
    float escala_counter = Defaults::Game::ContinueScreen::COUNTER_TEXT_SCALE;
    float y_ratio_counter = Defaults::Game::ContinueScreen::COUNTER_TEXT_Y_RATIO;

-    float centre_y_counter = play_area.y + play_area.h * y_ratio_counter;
+    float centre_y_counter = play_area.y + (play_area.h * y_ratio_counter);

-    text_.render_centered(counter_str, {centre_x, centre_y_counter}, escala_counter, spacing);
+    text_.render_centered(counter_str, {.x = centre_x, .y = centre_y_counter}, escala_counter, spacing);

    // "CONTINUES LEFT" (conditional + using constants)
    if (!Defaults::Game::INFINITE_CONTINUES) {
@@ -1400,9 +1371,9 @@ void EscenaJoc::dibuixar_continue() {
        float escala_info = Defaults::Game::ContinueScreen::INFO_TEXT_SCALE;
        float y_ratio_info = Defaults::Game::ContinueScreen::INFO_TEXT_Y_RATIO;

-        float centre_y_info = play_area.y + play_area.h * y_ratio_info;
+        float centre_y_info = play_area.y + (play_area.h * y_ratio_info);

-        text_.render_centered(continues_text, {centre_x, centre_y_info}, escala_info, spacing);
+        text_.render_centered(continues_text, {.x = centre_x, .y = centre_y_info}, escala_info, spacing);
    }
 }

@@ -1417,7 +1388,7 @@ void EscenaJoc::unir_jugador(uint8_t player_id) {
    // Reset stats
    vides_per_jugador_[player_id] = Defaults::Game::STARTING_LIVES;
    puntuacio_per_jugador_[player_id] = 0;
-    itocado_per_jugador_[player_id] = 0.0f;
+    itocado_per_jugador_[player_id] = 0.0F;

    // Spawn with invulnerability
    Punt spawn_pos = obtenir_punt_spawn(player_id);
@@ -1425,5 +1396,5 @@ void EscenaJoc::unir_jugador(uint8_t player_id) {

    // No visual message, just spawn (per user requirement)

-    std::cout << "[EscenaJoc] Jugador " << (int)(player_id + 1) << " s'ha unit a la partida!" << std::endl;
+    std::cout << "[EscenaJoc] Jugador " << (int)(player_id + 1) << " s'ha unit a la partida!" << '\n';
 }
--- a/source/game/escenes/escena_joc.hpp
+++ b/source/game/escenes/escena_joc.hpp
@@ -5,24 +5,24 @@
 #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 "../effects/gestor_puntuacio_flotant.hpp"
-#include "../entities/bala.hpp"
-#include "../entities/enemic.hpp"
-#include "../entities/nau.hpp"
-#include "../stage_system/stage_manager.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 {
@@ -81,13 +81,13 @@ class EscenaJoc {

        // Funcions privades
        void tocado(uint8_t player_id);
-        void detectar_col·lisions_bales_enemics();         // Col·lisions bala-enemic
-        void detectar_col·lisio_naus_enemics();            // Ship-enemy collision detection (plural)
-        void detectar_col·lisions_bales_jugadors();        // Bullet-player collision detection (friendly fire)
-        void dibuixar_marges() const;                      // Dibuixar vores de la zona de joc
-        void dibuixar_marcador();                          // Dibuixar marcador de puntuació
-        void disparar_bala(uint8_t player_id);             // Shoot bullet from player
-        Punt obtenir_punt_spawn(uint8_t player_id) const;  // Get spawn position for player
+        void detectar_col·lisions_bales_enemics();                       // Col·lisions bala-enemic
+        void detectar_col·lisio_naus_enemics();                          // Ship-enemy collision detection (plural)
+        void detectar_col·lisions_bales_jugadors();                      // Bullet-player collision detection (friendly fire)
+        void dibuixar_marges() const;                                    // Dibuixar vores de la zona de joc
+        void dibuixar_marcador();                                        // Dibuixar marcador de puntuació
+        void disparar_bala(uint8_t player_id);                           // Shoot bullet from player
+        [[nodiscard]] Punt obtenir_punt_spawn(uint8_t player_id) const;  // Get spawn position for player

        // [NEW] Continue & Join system
        void unir_jugador(uint8_t player_id);         // Join inactive player mid-game
@@ -100,15 +100,15 @@ class EscenaJoc {
        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
-        Punt calcular_posicio_nau_init_hud(float progress, uint8_t player_id) const;  // Posició animada de la nau
+        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
-        float calcular_progress_rango(float global_progress, float ratio_init, float ratio_end) const;
+        [[nodiscard]] float calcular_progress_rango(float global_progress, float ratio_init, float ratio_end) const;

        // [NEW] Funció helper del marcador
-        std::string construir_marcador() const;
+        [[nodiscard]] std::string construir_marcador() const;
 };

 #endif  // ESCENA_JOC_HPP
--- a/source/game/escenes/escena_logo.cpp
+++ b/source/game/escenes/escena_logo.cpp
@@ -25,33 +25,34 @@ using Opcio = ContextEscenes::Opcio;
 // Helper: calcular el progrés individual d'una lletra
 // en funció del progrés global (efecte seqüencial)
 static float calcular_progress_letra(size_t letra_index, size_t num_letras, float global_progress, float threshold) {
-    if (num_letras == 0)
-        return 1.0f;
+    if (num_letras == 0) {
+        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
-    } else if (global_progress >= end) {
-        return 1.0f;  // Completament apareguda
-    } else {
-        return (global_progress - start) / (end - start);
+        return 0.0F;  // Encara no ha començat
    }
+    if (global_progress >= end) {
+        return 1.0F;  // Completament apareguda
+    }
+    return (global_progress - start) / (end - start);
 }

 EscenaLogo::EscenaLogo(SDLManager& sdl, ContextEscenes& context)
    : sdl_(sdl),
      context_(context),
      estat_actual_(EstatAnimacio::PRE_ANIMATION),
-      temps_estat_actual_(0.0f),
+      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)
@@ -75,13 +76,11 @@ void EscenaLogo::executar() {
    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 = 0.05f;
-        }
+        delta_time = std::min(delta_time, 0.05F);

        // Actualitzar comptador de FPS
        sdl_.updateFPS(delta_time);
@@ -140,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;
        }

@@ -168,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});

@@ -179,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_ALTO = 480.0f;
+    constexpr float PANTALLA_ANCHO = 640.0F;
+    constexpr float PANTALLA_ALTO = 480.0F;

-    float x_inicial = (PANTALLA_ANCHO - ancho_total) / 2.0f;
-    float y_centre = PANTALLA_ALTO / 2.0f;
+    float x_inicial = (PANTALLA_ANCHO - ancho_total) / 2.0F;
+    float y_centre = PANTALLA_ALTO / 2.0F;

    // Pas 4: Assignar posicions a cada lletra
    float x_actual = x_inicial;
@@ -205,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();
@@ -244,20 +243,20 @@ void EscenaLogo::actualitzar_explosions(float delta_time) {
            const auto& lletra = lletres_[index_actual];

            debris_manager_->explotar(
-                lletra.forma,        // Forma a explotar
-                lletra.posicio,      // Posició
-                0.0f,                // Angle (sense rotació)
-                ESCALA_FINAL,        // Escala (lletres a escala final)
-                VELOCITAT_EXPLOSIO,  // Velocitat base
-                1.0f,                // Brightness màxim (per defecte)
-                {0.0f, 0.0f}         // Sense velocitat (per defecte)
+                lletra.forma,           // Forma a explotar
+                lletra.posicio,         // Posició
+                0.0F,                   // Angle (sense rotació)
+                ESCALA_FINAL,           // Escala (lletres a escala final)
+                VELOCITAT_EXPLOSIO,     // Velocitat base
+                1.0F,                   // Brightness màxim (per defecte)
+                {.x = 0.0F, .y = 0.0F}  // Sense velocitat (per defecte)
            );

            std::cout << "[EscenaLogo] Explota lletra " << lletra_explosio_index_ << "\n";

            // Passar a la següent lletra
            lletra_explosio_index_++;
-            temps_des_ultima_explosio_ = 0.0f;
+            temps_des_ultima_explosio_ = 0.0F;
        } else {
            // Totes les lletres han explotat, transició a POST_EXPLOSION
            canviar_estat(EstatAnimacio::POST_EXPLOSION);
@@ -277,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]) {
@@ -288,7 +287,7 @@ 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(Defaults::Sound::LOGO, Audio::Group::GAME);
                        so_reproduit_[i] = true;
                    }
@@ -345,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)
-            : 1.0f;  // POST: mantenir al 100%
+            ? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F)
+            : 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];
@@ -359,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);
        }
    }

@@ -395,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);
            }
        }
    }
--- a/source/game/escenes/escena_logo.hpp
+++ b/source/game/escenes/escena_logo.hpp
@@ -62,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_ZOOM = 4.0f;            // Duració del zoom (segons)
-        static constexpr float DURACIO_POST_ANIMATION = 3.0f;  // Duració POST_ANIMATION (logo complet)
-        static constexpr float DURACIO_POST_EXPLOSION = 3.0f;  // Duració POST_EXPLOSION (espera final)
-        static constexpr float DELAY_ENTRE_EXPLOSIONS = 0.1f;  // Temps entre explosions de lletres
-        static constexpr float VELOCITAT_EXPLOSIO = 240.0f;    // Velocitat base fragments (px/s)
-        static constexpr float ESCALA_INICIAL = 0.1f;          // Escala inicial (10%)
-        static constexpr float ESCALA_FINAL = 0.8f;            // Escala final (80%)
-        static constexpr float ESPAI_ENTRE_LLETRES = 10.0f;    // Espaiat entre lletres
+        static constexpr float DURACIO_PRE = 1.5F;             // Duració PRE_ANIMATION (pantalla negra)
+        static constexpr float DURACIO_ZOOM = 4.0F;            // Duració del zoom (segons)
+        static constexpr float DURACIO_POST_ANIMATION = 3.0F;  // Duració POST_ANIMATION (logo complet)
+        static constexpr float DURACIO_POST_EXPLOSION = 3.0F;  // Duració POST_EXPLOSION (espera final)
+        static constexpr float DELAY_ENTRE_EXPLOSIONS = 0.1F;  // Temps entre explosions de lletres
+        static constexpr float VELOCITAT_EXPLOSIO = 240.0F;    // Velocitat base fragments (px/s)
+        static constexpr float ESCALA_INICIAL = 0.1F;          // Escala inicial (10%)
+        static constexpr float ESCALA_FINAL = 0.8F;            // Escala final (80%)
+        static constexpr float ESPAI_ENTRE_LLETRES = 10.0F;    // Espaiat entre lletres

        // Constants d'animació seqüencial
-        static constexpr float THRESHOLD_LETRA = 0.6f;                         // Umbral per activar següent lletra (0.0-1.0)
-        static constexpr float ORIGEN_ZOOM_X = Defaults::Game::WIDTH * 0.5f;   // Punt inicial X del zoom
-        static constexpr float ORIGEN_ZOOM_Y = Defaults::Game::HEIGHT * 0.4f;  // Punt inicial Y del zoom
+        static constexpr float THRESHOLD_LETRA = 0.6F;                         // Umbral per activar següent lletra (0.0-1.0)
+        static constexpr float ORIGEN_ZOOM_X = Defaults::Game::WIDTH * 0.5F;   // Punt inicial X del zoom
+        static constexpr float ORIGEN_ZOOM_Y = Defaults::Game::HEIGHT * 0.4F;  // Punt inicial Y del zoom

        // Mètodes privats
        void inicialitzar_lletres();
@@ -87,5 +87,5 @@ class EscenaLogo {

        // Mètodes de gestió d'estats
        void canviar_estat(EstatAnimacio nou_estat);
-        bool totes_lletres_completes() const;
+        [[nodiscard]] bool totes_lletres_completes() const;
 };
--- a/source/game/escenes/escena_titol.cpp
+++ b/source/game/escenes/escena_titol.cpp
@@ -3,9 +3,11 @@

 #include "escena_titol.hpp"

+#include <algorithm>
 #include <cfloat>
 #include <cmath>
 #include <iostream>
+#include <numbers>
 #include <string>

 #include "core/audio/audio.hpp"
@@ -27,11 +29,11 @@ EscenaTitol::EscenaTitol(SDLManager& sdl, ContextEscenes& context)
      context_(context),
      text_(sdl.obte_renderer()),
      estat_actual_(EstatTitol::STARFIELD_FADE_IN),
-      temps_acumulat_(0.0f),
-      temps_animacio_(0.0f),
-      temps_estat_main_(0.0f),
+      temps_acumulat_(0.0F),
+      temps_animacio_(0.0F),
+      temps_estat_main_(0.0F),
      animacio_activa_(false),
-      factor_lerp_(0.0f) {
+      factor_lerp_(0.0F) {
    std::cout << "Escena Titol: Inicialitzant...\n";

    // Inicialitzar configuració de partida (cap jugador actiu per defecte)
@@ -45,13 +47,13 @@ EscenaTitol::EscenaTitol(SDLManager& sdl, ContextEscenes& context)
    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;
+        temps_estat_main_ = 0.0F;
    }

    // Crear starfield de fons
    Punt centre_pantalla{
-        Defaults::Game::WIDTH / 2.0f,
-        Defaults::Game::HEIGHT / 2.0f};
+        .x = Defaults::Game::WIDTH / 2.0F,
+        .y = Defaults::Game::HEIGHT / 2.0F};

    SDL_FRect area_completa{
        0,
@@ -72,7 +74,7 @@ EscenaTitol::EscenaTitol(SDLManager& sdl, ContextEscenes& context)
        starfield_->set_brightness(BRIGHTNESS_STARFIELD);
    } else {
        // Flux normal: comença amb brightness 0.0 per fade-in
-        starfield_->set_brightness(0.0f);
+        starfield_->set_brightness(0.0F);
    }

    // Inicialitzar animador de naus 3D
@@ -113,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;
        }

@@ -145,7 +147,7 @@ void EscenaTitol::inicialitzar_titol() {
        float altura = altura_sin_escalar * Defaults::Title::Layout::LOGO_SCALE;
        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;
    }
@@ -154,7 +156,7 @@ 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_) {
@@ -168,7 +170,7 @@ 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;
    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;
@@ -187,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;
        }

@@ -219,7 +221,7 @@ void EscenaTitol::inicialitzar_titol() {
        float altura = altura_sin_escalar * Defaults::Title::Layout::LOGO_SCALE;
        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;
    }
@@ -228,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_) {
@@ -261,13 +263,11 @@ void EscenaTitol::executar() {
    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 = 0.05f;
-        }
+        delta_time = std::min(delta_time, 0.05F);

        // Actualitzar comptador de FPS
        sdl_.updateFPS(delta_time);
@@ -339,7 +339,7 @@ void EscenaTitol::actualitzar(float delta_time) {
            temps_acumulat_ += delta_time;

            // Calcular progrés del fade (0.0 → 1.0)
-            float progress = std::min(1.0f, temps_acumulat_ / DURACIO_FADE_IN);
+            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;
@@ -348,7 +348,7 @@ void EscenaTitol::actualitzar(float delta_time) {
            // 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
+                temps_acumulat_ = 0.0F;                            // Reset timer per al següent estat
                starfield_->set_brightness(BRIGHTNESS_STARFIELD);  // Assegurar valor final
            }
            break;
@@ -358,9 +358,9 @@ void EscenaTitol::actualitzar(float delta_time) {
            temps_acumulat_ += delta_time;
            if (temps_acumulat_ >= DURACIO_INIT) {
                estat_actual_ = EstatTitol::MAIN;
-                temps_estat_main_ = 0.0f;  // Reset timer al entrar a MAIN
+                temps_estat_main_ = 0.0F;  // Reset timer al entrar a MAIN
                animacio_activa_ = false;  // Comença estàtic
-                factor_lerp_ = 0.0f;       // Sense animació encara
+                factor_lerp_ = 0.0F;       // Sense animació encara

                // Naus esperaran ENTRANCE_DELAY abans d'entrar (no iniciar aquí)
            }
@@ -379,7 +379,7 @@ void EscenaTitol::actualitzar(float delta_time) {

            // Fase 1: Estàtic (0-10s)
            if (temps_estat_main_ < DELAY_INICI_ANIMACIO) {
-                factor_lerp_ = 0.0f;
+                factor_lerp_ = 0.0F;
                animacio_activa_ = false;
            }
            // Fase 2: Lerp (10-12s)
@@ -390,7 +390,7 @@ void EscenaTitol::actualitzar(float delta_time) {
            }
            // Fase 3: Animació completa (12s+)
            else {
-                factor_lerp_ = 1.0f;
+                factor_lerp_ = 1.0F;
                animacio_activa_ = true;
            }

@@ -430,7 +430,7 @@ void EscenaTitol::actualitzar(float delta_time) {
                    Audio::get()->playSound(Defaults::Sound::START, Audio::Group::GAME);

                    // Reiniciar el timer per allargar el temps de transició
-                    temps_acumulat_ = 0.0f;
+                    temps_acumulat_ = 0.0F;

                    std::cout << "[EscenaTitol] Segon jugador s'ha unit - so i timer reiniciats\n";
                }
@@ -439,7 +439,7 @@ void EscenaTitol::actualitzar(float delta_time) {
            if (temps_acumulat_ >= DURACIO_TRANSITION) {
                // Transició a pantalla negra
                estat_actual_ = EstatTitol::BLACK_SCREEN;
-                temps_acumulat_ = 0.0f;
+                temps_acumulat_ = 0.0F;
                std::cout << "[EscenaTitol] Passant a BLACK_SCREEN\n";
            }
            break;
@@ -462,7 +462,7 @@ void EscenaTitol::actualitzar(float delta_time) {
            // Saltar a MAIN
            estat_actual_ = EstatTitol::MAIN;
            starfield_->set_brightness(BRIGHTNESS_STARFIELD);
-            temps_estat_main_ = 0.0f;
+            temps_estat_main_ = 0.0F;

            // Naus esperaran ENTRANCE_DELAY abans d'entrar (no iniciar aquí)
        }
@@ -487,11 +487,11 @@ void EscenaTitol::actualitzar(float delta_time) {
                      << (config_partida_.jugador1_actiu ? "ACTIU" : "INACTIU")
                      << ", P2: "
                      << (config_partida_.jugador2_actiu ? "ACTIU" : "INACTIU")
-                      << std::endl;
+                      << '\n';

            context_.canviar_escena(Escena::JOC);
            estat_actual_ = EstatTitol::PLAYER_JOIN_PHASE;
-            temps_acumulat_ = 0.0f;
+            temps_acumulat_ = 0.0F;

            // Trigger animació de sortida NOMÉS per les naus que han premut START
            if (ship_animator_) {
@@ -524,8 +524,8 @@ void EscenaTitol::actualitzar_animacio_logo(float delta_time) {
        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);
+        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) {
@@ -567,7 +567,7 @@ void EscenaTitol::dibuixar() {
        // === Calcular i renderitzar ombra (només si animació activa) ===
        if (animacio_activa_) {
            float temps_shadow = temps_animacio_ - SHADOW_DELAY;
-            if (temps_shadow < 0.0f) temps_shadow = 0.0f;  // Evitar temps negatiu
+            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;
@@ -576,8 +576,8 @@ void EscenaTitol::dibuixar() {
            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;
+            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) ===

@@ -591,10 +591,10 @@ void EscenaTitol::dibuixar() {
                    sdl_.obte_renderer(),
                    lletres_orni_[i].forma,
                    pos_shadow,
-                    0.0f,
+                    0.0F,
                    Defaults::Title::Layout::LOGO_SCALE,
                    true,
-                    1.0f,              // progress = 1.0 (totalment visible)
+                    1.0F,              // progress = 1.0 (totalment visible)
                    SHADOW_BRIGHTNESS  // brightness = 0.4 (brillantor reduïda)
                );
            }
@@ -609,10 +609,10 @@ void EscenaTitol::dibuixar() {
                    sdl_.obte_renderer(),
                    lletres_attack_[i].forma,
                    pos_shadow,
-                    0.0f,
+                    0.0F,
                    Defaults::Title::Layout::LOGO_SCALE,
                    true,
-                    1.0f,  // progress = 1.0 (totalment visible)
+                    1.0F,  // progress = 1.0 (totalment visible)
                    SHADOW_BRIGHTNESS);
            }
        }
@@ -625,10 +625,10 @@ void EscenaTitol::dibuixar() {
                sdl_.obte_renderer(),
                lletra.forma,
                lletra.posicio,
-                0.0f,
+                0.0F,
                Defaults::Title::Layout::LOGO_SCALE,
                true,
-                1.0f  // Brillantor completa
+                1.0F  // Brillantor completa
            );
        }

@@ -638,10 +638,10 @@ void EscenaTitol::dibuixar() {
                sdl_.obte_renderer(),
                lletra.forma,
                lletra.posicio,
-                0.0f,
+                0.0F,
                Defaults::Title::Layout::LOGO_SCALE,
                true,
-                1.0f  // Brillantor completa
+                1.0F  // Brillantor completa
            );
        }

@@ -654,18 +654,18 @@ void EscenaTitol::dibuixar() {
        bool mostrar_text = true;
        if (estat_actual_ == EstatTitol::PLAYER_JOIN_PHASE) {
            // Parpelleig: sin oscil·la entre -1 i 1, volem ON quan > 0
-            float fase = temps_acumulat_ * BLINK_FREQUENCY * 2.0f * 3.14159f;  // 2π × freq × temps
-            mostrar_text = (std::sin(fase) > 0.0f);
+            float fase = temps_acumulat_ * BLINK_FREQUENCY * 2.0F * std::numbers::pi_v<float>;  // 2π × freq × temps
+            mostrar_text = (std::sin(fase) > 0.0F);
        }

        if (mostrar_text) {
            const std::string main_text = "PRESS START TO PLAY";
            const float escala_main = Defaults::Title::Layout::PRESS_START_SCALE;

-            float centre_x = Defaults::Game::WIDTH / 2.0f;
+            float centre_x = Defaults::Game::WIDTH / 2.0F;
            float centre_y = Defaults::Game::HEIGHT * Defaults::Title::Layout::PRESS_START_POS;

-            text_.render_centered(main_text, {centre_x, centre_y}, escala_main, spacing);
+            text_.render_centered(main_text, {.x = centre_x, .y = centre_y}, escala_main, spacing);
        }

        // === Copyright a la part inferior (centrat horitzontalment, dues línies) ===
@@ -676,13 +676,17 @@ void EscenaTitol::dibuixar() {
        // 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;  // Uppercase
+            if (c >= 'a' && c <= 'z') {
+                c = c - 32;  // Uppercase
+            }
        }

        // Línea 2: Port (© 2025 jaildesigner)
        std::string copyright_port = Project::COPYRIGHT_PORT;
        for (char& c : copyright_port) {
-            if (c >= 'a' && c <= 'z') c = c - 32;  // Uppercase
+            if (c >= 'a' && c <= 'z') {
+                c = c - 32;  // Uppercase
+            }
        }

        // Calcular posicions (anclatge des del top + separació)
@@ -690,10 +694,10 @@ void EscenaTitol::dibuixar() {
        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;
+        float centre_x = Defaults::Game::WIDTH / 2.0F;

-        text_.render_centered(copyright_original, {centre_x, y_line1}, escala_copy, spacing);
-        text_.render_centered(copyright_port, {centre_x, y_line2}, escala_copy, spacing);
+        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);
    }
 }

--- a/source/game/escenes/escena_titol.hpp
+++ b/source/game/escenes/escena_titol.hpp
@@ -75,31 +75,31 @@ class EscenaTitol {
        float factor_lerp_;       // Factor de lerp actual (0.0 → 1.0)

        // Constants
-        static constexpr float BRIGHTNESS_STARFIELD = 1.2f;  // Brightness del starfield (>1.0 = més brillant)
-        static constexpr float DURACIO_FADE_IN = 3.0f;       // Duració del fade-in del starfield (1.5 segons)
-        static constexpr float DURACIO_INIT = 4.0f;          // Duració de l'estat INIT (2 segons)
-        static constexpr float DURACIO_TRANSITION = 2.5f;    // Duració de la transició (1.5 segons)
-        static constexpr float ESPAI_ENTRE_LLETRES = 10.0f;  // Espai entre lletres
-        static constexpr float BLINK_FREQUENCY = 3.0f;       // Freqüència de parpelleig (3 Hz)
-        static constexpr float DURACIO_BLACK_SCREEN = 2.0f;  // Duració pantalla negra (2 segons)
+        static constexpr float BRIGHTNESS_STARFIELD = 1.2F;  // Brightness del starfield (>1.0 = més brillant)
+        static constexpr float DURACIO_FADE_IN = 3.0F;       // Duració del fade-in del starfield (1.5 segons)
+        static constexpr float DURACIO_INIT = 4.0F;          // Duració de l'estat INIT (2 segons)
+        static constexpr float DURACIO_TRANSITION = 2.5F;    // Duració de la transició (1.5 segons)
+        static constexpr float ESPAI_ENTRE_LLETRES = 10.0F;  // Espai entre lletres
+        static constexpr float BLINK_FREQUENCY = 3.0F;       // Freqüència de parpelleig (3 Hz)
+        static constexpr float DURACIO_BLACK_SCREEN = 2.0F;  // Duració pantalla negra (2 segons)
        static constexpr int MUSIC_FADE = 1500;              // Duracio del fade de la musica del titol al començar a jugar

        // Constants d'animació del logo
-        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)
+        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)
+        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
+        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);
--- a/source/game/options.cpp
+++ b/source/game/options.cpp
@@ -189,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
@@ -261,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 (...) {
@@ -395,8 +395,8 @@ static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {

        if (aud.contains("volume")) {
            try {
-                float val = aud["volume"].get_value<float>();
-                audio.volume = (val >= 0.0f && val <= 1.0f) ? val : Defaults::Audio::VOLUME;
+                auto val = aud["volume"].get_value<float>();
+                audio.volume = (val >= 0.0F && val <= 1.0F) ? val : Defaults::Audio::VOLUME;
            } catch (...) {
                audio.volume = Defaults::Audio::VOLUME;
            }
@@ -415,8 +415,8 @@ static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {

            if (mus.contains("volume")) {
                try {
-                    float val = mus["volume"].get_value<float>();
-                    audio.music.volume = (val >= 0.0f && val <= 1.0f) ? val : Defaults::Music::VOLUME;
+                    auto val = mus["volume"].get_value<float>();
+                    audio.music.volume = (val >= 0.0F && val <= 1.0F) ? val : Defaults::Music::VOLUME;
                } catch (...) {
                    audio.music.volume = Defaults::Music::VOLUME;
                }
@@ -436,8 +436,8 @@ static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {

            if (snd.contains("volume")) {
                try {
-                    float val = snd["volume"].get_value<float>();
-                    audio.sound.volume = (val >= 0.0f && val <= 1.0f) ? val : Defaults::Sound::VOLUME;
+                    auto val = snd["volume"].get_value<float>();
+                    audio.sound.volume = (val >= 0.0F && val <= 1.0F) ? val : Defaults::Sound::VOLUME;
                } catch (...) {
                    audio.sound.volume = Defaults::Sound::VOLUME;
                }
@@ -448,76 +448,98 @@ 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;
+    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"))
+        if (kb.contains("key_left")) {
            player1.keyboard.key_left = stringToScancode(kb["key_left"].get_value<std::string>());
-        if (kb.contains("key_right"))
+        }
+        if (kb.contains("key_right")) {
            player1.keyboard.key_right = stringToScancode(kb["key_right"].get_value<std::string>());
-        if (kb.contains("key_thrust"))
+        }
+        if (kb.contains("key_thrust")) {
            player1.keyboard.key_thrust = stringToScancode(kb["key_thrust"].get_value<std::string>());
-        if (kb.contains("key_shoot"))
+        }
+        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"))
+        if (gp.contains("button_left")) {
            player1.gamepad.button_left = stringToButton(gp["button_left"].get_value<std::string>());
-        if (gp.contains("button_right"))
+        }
+        if (gp.contains("button_right")) {
            player1.gamepad.button_right = stringToButton(gp["button_right"].get_value<std::string>());
-        if (gp.contains("button_thrust"))
+        }
+        if (gp.contains("button_thrust")) {
            player1.gamepad.button_thrust = stringToButton(gp["button_thrust"].get_value<std::string>());
-        if (gp.contains("button_shoot"))
+        }
+        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"))
+    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;
+    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"))
+        if (kb.contains("key_left")) {
            player2.keyboard.key_left = stringToScancode(kb["key_left"].get_value<std::string>());
-        if (kb.contains("key_right"))
+        }
+        if (kb.contains("key_right")) {
            player2.keyboard.key_right = stringToScancode(kb["key_right"].get_value<std::string>());
-        if (kb.contains("key_thrust"))
+        }
+        if (kb.contains("key_thrust")) {
            player2.keyboard.key_thrust = stringToScancode(kb["key_thrust"].get_value<std::string>());
-        if (kb.contains("key_shoot"))
+        }
+        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"))
+        if (gp.contains("button_left")) {
            player2.gamepad.button_left = stringToButton(gp["button_left"].get_value<std::string>());
-        if (gp.contains("button_right"))
+        }
+        if (gp.contains("button_right")) {
            player2.gamepad.button_right = stringToButton(gp["button_right"].get_value<std::string>());
-        if (gp.contains("button_thrust"))
+        }
+        if (gp.contains("button_thrust")) {
            player2.gamepad.button_thrust = stringToButton(gp["button_thrust"].get_value<std::string>());
-        if (gp.contains("button_shoot"))
+        }
+        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"))
+    if (p2.contains("gamepad_name")) {
        player2.gamepad_name = p2["gamepad_name"].get_value<std::string>();
+    }
 }

 // Carregar configuració des del fitxer YAML
--- a/source/game/options.hpp
+++ b/source/game/options.hpp
@@ -12,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 acceleration{400.0f};   // px/s²
-        float max_velocity{120.0f};   // px/s
-        float friction{20.0f};        // px/s²
-        float enemy_speed{2.0f};      // unitats/frame
-        float bullet_speed{6.0f};     // unitats/frame
+        float rotation_speed{3.14F};  // rad/s
+        float acceleration{400.0F};   // px/s²
+        float max_velocity{120.0F};   // px/s
+        float friction{20.0F};        // px/s²
+        float enemy_speed{2.0F};      // unitats/frame
+        float bullet_speed{6.0F};     // unitats/frame
 };

 struct Gameplay {
@@ -35,19 +35,19 @@ 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
@@ -70,7 +70,7 @@ struct GamepadControls {
 struct PlayerControls {
        KeyboardControls keyboard{};
        GamepadControls gamepad{};
-        std::string gamepad_name{""};  // Buit = auto-assignar per índex
+        std::string gamepad_name;  // Buit = auto-assignar per índex
 };

 // Variables globals (inline per evitar ODR violations)
--- a/source/game/stage_system/spawn_controller.cpp
+++ b/source/game/stage_system/spawn_controller.cpp
@@ -3,14 +3,21 @@

 #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),
+      temps_transcorregut_(0.0F),
      index_spawn_actual_(0),
      ship_position_(nullptr) {}

@@ -19,8 +26,8 @@ void SpawnController::configurar(const ConfigStage* config) {
 }

 void SpawnController::iniciar() {
-    if (!config_) {
-        std::cerr << "[SpawnController] Error: config_ és null" << std::endl;
+    if (config_ == nullptr) {
+        std::cerr << "[SpawnController] Error: config_ és null" << '\n';
        return;
    }

@@ -28,17 +35,17 @@ void SpawnController::iniciar() {
    generar_spawn_events();

    std::cout << "[SpawnController] Stage " << static_cast<int>(config_->stage_id)
-              << ": generats " << spawn_queue_.size() << " spawn events" << std::endl;
+              << ": generats " << spawn_queue_.size() << " spawn events" << '\n';
 }

 void SpawnController::reset() {
    spawn_queue_.clear();
-    temps_transcorregut_ = 0.0f;
+    temps_transcorregut_ = 0.0F;
    index_spawn_actual_ = 0;
 }

 void SpawnController::actualitzar(float delta_time, std::array<Enemic, 15>& orni_array, bool pausar) {
-    if (!config_ || spawn_queue_.empty()) {
+    if ((config_ == nullptr) || spawn_queue_.empty()) {
        return;
    }

@@ -111,7 +118,7 @@ uint8_t SpawnController::get_enemics_spawnejats() const {
 }

 void SpawnController::generar_spawn_events() {
-    if (!config_) {
+    if (config_ == nullptr) {
        return;
    }

@@ -126,20 +133,20 @@ void SpawnController::generar_spawn_events() {
 }

 TipusEnemic SpawnController::seleccionar_tipus_aleatori() const {
-    if (!config_) {
+    if (config_ == nullptr) {
        return TipusEnemic::PENTAGON;
    }

    // Weighted random selection based on distribution
    int rand_val = std::rand() % 100;

-    if (rand_val < config_->distribucio.pentagon) {
+    if (std::cmp_less(rand_val, config_->distribucio.pentagon)) {
        return TipusEnemic::PENTAGON;
-    } else if (rand_val < config_->distribucio.pentagon + config_->distribucio.quadrat) {
-        return TipusEnemic::QUADRAT;
-    } else {
-        return TipusEnemic::MOLINILLO;
    }
+    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) {
@@ -151,7 +158,7 @@ void SpawnController::spawn_enemic(Enemic& enemic, TipusEnemic tipus, const Punt
 }

 void SpawnController::aplicar_multiplicadors(Enemic& enemic) const {
-    if (!config_) {
+    if (config_ == nullptr) {
        return;
    }

--- a/source/game/stage_system/spawn_controller.hpp
+++ b/source/game/stage_system/spawn_controller.hpp
@@ -33,10 +33,10 @@ class SpawnController {
        void actualitzar(float delta_time, std::array<Enemic, 15>& orni_array, bool pausar = false);

        // Status queries
-        bool tots_enemics_spawnejats() const;
-        bool tots_enemics_destruits(const std::array<Enemic, 15>& orni_array) const;
-        uint8_t get_enemics_vius(const std::array<Enemic, 15>& orni_array) const;
-        uint8_t get_enemics_spawnejats() const;
+        [[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; }
@@ -49,7 +49,7 @@ class SpawnController {

        // Spawn generation
        void generar_spawn_events();
-        TipusEnemic seleccionar_tipus_aleatori() const;
+        [[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
--- a/source/game/stage_system/stage_config.hpp
+++ b/source/game/stage_system/stage_config.hpp
@@ -55,7 +55,7 @@ struct ConfigStage {
        MultiplicadorsDificultat multiplicadors;

        // Validació
-        bool es_valid() const {
+        [[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;
@@ -68,7 +68,7 @@ struct ConfigSistemaStages {
        std::vector<ConfigStage> stages;  // Índex [0] = stage 1

        // Obtenir configuració d'un stage específic
-        const ConfigStage* obte_stage(uint8_t stage_id) const {
+        [[nodiscard]] const ConfigStage* obte_stage(uint8_t stage_id) const {
            if (stage_id < 1 || stage_id > stages.size()) {
                return nullptr;
            }
--- a/source/game/stage_system/stage_loader.cpp
+++ b/source/game/stage_system/stage_loader.cpp
@@ -3,12 +3,19 @@

 #include "stage_loader.hpp"

-#include <fstream>
+#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 {

@@ -23,7 +30,7 @@ std::unique_ptr<ConfigSistemaStages> StageLoader::carregar(const std::string& pa
        // Load from resource system
        std::vector<uint8_t> data = Resource::Helper::loadFile(normalized);
        if (data.empty()) {
-            std::cerr << "[StageLoader] Error: no es pot carregar " << normalized << std::endl;
+            std::cerr << "[StageLoader] Error: no es pot carregar " << normalized << '\n';
            return nullptr;
        }

@@ -37,7 +44,7 @@ std::unique_ptr<ConfigSistemaStages> StageLoader::carregar(const std::string& pa

        // Parse metadata
        if (!yaml.contains("metadata")) {
-            std::cerr << "[StageLoader] Error: falta camp 'metadata'" << std::endl;
+            std::cerr << "[StageLoader] Error: falta camp 'metadata'" << '\n';
            return nullptr;
        }
        if (!parse_metadata(yaml["metadata"], config->metadata)) {
@@ -46,12 +53,12 @@ std::unique_ptr<ConfigSistemaStages> StageLoader::carregar(const std::string& pa

        // Parse stages
        if (!yaml.contains("stages")) {
-            std::cerr << "[StageLoader] Error: falta camp 'stages'" << std::endl;
+            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" << std::endl;
+            std::cerr << "[StageLoader] Error: 'stages' ha de ser una llista" << '\n';
            return nullptr;
        }

@@ -69,11 +76,11 @@ std::unique_ptr<ConfigSistemaStages> StageLoader::carregar(const std::string& pa
        }

        std::cout << "[StageLoader] Carregats " << config->stages.size()
-                  << " stages correctament" << std::endl;
+                  << " stages correctament" << '\n';
        return config;

    } catch (const std::exception& e) {
-        std::cerr << "[StageLoader] Excepció: " << e.what() << std::endl;
+        std::cerr << "[StageLoader] Excepció: " << e.what() << '\n';
        return nullptr;
    }
 }
@@ -81,7 +88,7 @@ std::unique_ptr<ConfigSistemaStages> StageLoader::carregar(const std::string& pa
 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" << std::endl;
+            std::cerr << "[StageLoader] Error: metadata incompleta" << '\n';
            return false;
        }

@@ -93,7 +100,7 @@ bool StageLoader::parse_metadata(const fkyaml::node& yaml, MetadataStages& meta)

        return true;
    } catch (const std::exception& e) {
-        std::cerr << "[StageLoader] Error parsing metadata: " << e.what() << std::endl;
+        std::cerr << "[StageLoader] Error parsing metadata: " << e.what() << '\n';
        return false;
    }
 }
@@ -103,7 +110,7 @@ bool StageLoader::parse_stage(const fkyaml::node& yaml, ConfigStage& stage) {
        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" << std::endl;
+            std::cerr << "[StageLoader] Error: stage incompleta" << '\n';
            return false;
        }

@@ -122,13 +129,13 @@ bool StageLoader::parse_stage(const fkyaml::node& yaml, ConfigStage& stage) {

        if (!stage.es_valid()) {
            std::cerr << "[StageLoader] Error: stage " << static_cast<int>(stage.stage_id)
-                      << " no és vàlid" << std::endl;
+                      << " no és vàlid" << '\n';
            return false;
        }

        return true;
    } catch (const std::exception& e) {
-        std::cerr << "[StageLoader] Error parsing stage: " << e.what() << std::endl;
+        std::cerr << "[StageLoader] Error parsing stage: " << e.what() << '\n';
        return false;
    }
 }
@@ -137,18 +144,18 @@ bool StageLoader::parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& conf
    try {
        if (!yaml.contains("mode") || !yaml.contains("initial_delay") ||
            !yaml.contains("spawn_interval")) {
-            std::cerr << "[StageLoader] Error: spawn_config incompleta" << std::endl;
+            std::cerr << "[StageLoader] Error: spawn_config incompleta" << '\n';
            return false;
        }

-        std::string mode_str = yaml["mode"].get_value<std::string>();
+        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() << std::endl;
+        std::cerr << "[StageLoader] Error parsing spawn_config: " << e.what() << '\n';
        return false;
    }
 }
@@ -157,7 +164,7 @@ bool StageLoader::parse_distribution(const fkyaml::node& yaml, DistribucioEnemic
    try {
        if (!yaml.contains("pentagon") || !yaml.contains("quadrat") ||
            !yaml.contains("molinillo")) {
-            std::cerr << "[StageLoader] Error: enemy_distribution incompleta" << std::endl;
+            std::cerr << "[StageLoader] Error: enemy_distribution incompleta" << '\n';
            return false;
        }

@@ -168,13 +175,13 @@ bool StageLoader::parse_distribution(const fkyaml::node& yaml, DistribucioEnemic
        // 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 << ")" << std::endl;
+            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() << std::endl;
+        std::cerr << "[StageLoader] Error parsing distribution: " << e.what() << '\n';
        return false;
    }
 }
@@ -183,7 +190,7 @@ bool StageLoader::parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDifi
    try {
        if (!yaml.contains("speed_multiplier") || !yaml.contains("rotation_multiplier") ||
            !yaml.contains("tracking_strength")) {
-            std::cerr << "[StageLoader] Error: difficulty_multipliers incompleta" << std::endl;
+            std::cerr << "[StageLoader] Error: difficulty_multipliers incompleta" << '\n';
            return false;
        }

@@ -192,19 +199,19 @@ bool StageLoader::parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDifi
        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)" << std::endl;
+        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)" << std::endl;
+        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)" << std::endl;
+        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() << std::endl;
+        std::cerr << "[StageLoader] Error parsing multipliers: " << e.what() << '\n';
        return false;
    }
 }
@@ -212,27 +219,28 @@ bool StageLoader::parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDifi
 ModeSpawn StageLoader::parse_spawn_mode(const std::string& mode_str) {
    if (mode_str == "progressive") {
        return ModeSpawn::PROGRESSIVE;
-    } else if (mode_str == "immediate") {
-        return ModeSpawn::IMMEDIATE;
-    } else if (mode_str == "wave") {
-        return ModeSpawn::WAVE;
-    } else {
-        std::cerr << "[StageLoader] Warning: mode de spawn desconegut '" << mode_str
-                  << "', usant PROGRESSIVE" << std::endl;
-        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" << std::endl;
+        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) << ")" << std::endl;
+                  << static_cast<int>(config.metadata.total_stages) << ")" << '\n';
    }

    // Validar stage_id consecutius
@@ -240,7 +248,7 @@ bool StageLoader::validar_config(const ConfigSistemaStages& config) {
        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)
-                      << ")" << std::endl;
+                      << ")" << '\n';
            return false;
        }
    }
--- a/source/game/stage_system/stage_manager.cpp
+++ b/source/game/stage_system/stage_manager.cpp
@@ -3,10 +3,14 @@

 #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 {

@@ -14,9 +18,9 @@ StageManager::StageManager(const ConfigSistemaStages* config)
    : config_(config),
      estat_(EstatStage::LEVEL_START),
      stage_actual_(1),
-      timer_transicio_(0.0f) {
-    if (!config_) {
-        std::cerr << "[StageManager] Error: config és null" << std::endl;
+      timer_transicio_(0.0F) {
+    if (config_ == nullptr) {
+        std::cerr << "[StageManager] Error: config és null" << '\n';
    }
 }

@@ -26,7 +30,7 @@ void StageManager::inicialitzar() {
    canviar_estat(EstatStage::INIT_HUD);

    std::cout << "[StageManager] Inicialitzat a stage " << static_cast<int>(stage_actual_)
-              << std::endl;
+              << '\n';
 }

 void StageManager::actualitzar(float delta_time, bool pausar_spawn) {
@@ -51,14 +55,14 @@ void StageManager::actualitzar(float delta_time, bool pausar_spawn) {

 void StageManager::stage_completat() {
    std::cout << "[StageManager] Stage " << static_cast<int>(stage_actual_) << " completat!"
-              << std::endl;
+              << '\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;
+        timer_transicio_ <= 0.0F;
 }

 const ConfigStage* StageManager::get_config_actual() const {
@@ -104,13 +108,13 @@ void StageManager::canviar_estat(EstatStage nou_estat) {
            std::cout << "LEVEL_COMPLETED";
            break;
    }
-    std::cout << std::endl;
+    std::cout << '\n';
 }

 void StageManager::processar_init_hud(float delta_time) {
    timer_transicio_ -= delta_time;

-    if (timer_transicio_ <= 0.0f) {
+    if (timer_transicio_ <= 0.0F) {
        canviar_estat(EstatStage::LEVEL_START);
    }
 }
@@ -118,7 +122,7 @@ void StageManager::processar_init_hud(float delta_time) {
 void StageManager::processar_level_start(float delta_time) {
    timer_transicio_ -= delta_time;

-    if (timer_transicio_ <= 0.0f) {
+    if (timer_transicio_ <= 0.0F) {
        canviar_estat(EstatStage::PLAYING);
    }
 }
@@ -134,7 +138,7 @@ void StageManager::processar_playing(float delta_time, bool pausar_spawn) {
 void StageManager::processar_level_completed(float delta_time) {
    timer_transicio_ -= delta_time;

-    if (timer_transicio_ <= 0.0f) {
+    if (timer_transicio_ <= 0.0F) {
        // Advance to next stage
        stage_actual_++;

@@ -142,7 +146,7 @@ void StageManager::processar_level_completed(float delta_time) {
        if (stage_actual_ > config_->metadata.total_stages) {
            stage_actual_ = 1;
            std::cout << "[StageManager] Totes les stages completades! Tornant a stage 1"
-                      << std::endl;
+                      << '\n';
        }

        // Load next stage
@@ -153,9 +157,9 @@ void StageManager::processar_level_completed(float delta_time) {

 void StageManager::carregar_stage(uint8_t stage_id) {
    const ConfigStage* stage_config = config_->obte_stage(stage_id);
-    if (!stage_config) {
+    if (stage_config == nullptr) {
        std::cerr << "[StageManager] Error: no es pot trobar stage " << static_cast<int>(stage_id)
-                  << std::endl;
+                  << '\n';
        return;
    }

@@ -164,7 +168,7 @@ void StageManager::carregar_stage(uint8_t stage_id) {
    spawn_controller_.iniciar();

    std::cout << "[StageManager] Carregat stage " << static_cast<int>(stage_id) << ": "
-              << static_cast<int>(stage_config->total_enemics) << " enemics" << std::endl;
+              << static_cast<int>(stage_config->total_enemics) << " enemics" << '\n';
 }

 }  // namespace StageSystem
--- a/source/game/stage_system/stage_manager.hpp
+++ b/source/game/stage_system/stage_manager.hpp
@@ -4,7 +4,7 @@
 #pragma once

 #include <cstdint>
-#include <memory>
+#include <string>

 #include "spawn_controller.hpp"
 #include "stage_config.hpp"
@@ -28,19 +28,19 @@ class StageManager {
        void actualitzar(float delta_time, bool pausar_spawn = false);

        // Stage progression
-        void stage_completat();      // Call when all enemies destroyed
-        bool tot_completat() const;  // All 10 stages done?
+        void stage_completat();                    // Call when all enemies destroyed
+        [[nodiscard]] bool tot_completat() const;  // All 10 stages done?

        // Current state queries
-        EstatStage get_estat() const { return estat_; }
-        uint8_t get_stage_actual() const { return stage_actual_; }
-        const ConfigStage* get_config_actual() const;
-        float get_timer_transicio() const { return timer_transicio_; }
-        const std::string& get_missatge_level_start() const { return missatge_level_start_actual_; }
+        [[nodiscard]] EstatStage get_estat() const { return estat_; }
+        [[nodiscard]] uint8_t get_stage_actual() const { return stage_actual_; }
+        [[nodiscard]] const ConfigStage* get_config_actual() const;
+        [[nodiscard]] float get_timer_transicio() const { return timer_transicio_; }
+        [[nodiscard]] const std::string& get_missatge_level_start() const { return missatge_level_start_actual_; }

        // Spawn control (delegate to SpawnController)
        SpawnController& get_spawn_controller() { return spawn_controller_; }
-        const SpawnController& get_spawn_controller() const { return spawn_controller_; }
+        [[nodiscard]] const SpawnController& get_spawn_controller() const { return spawn_controller_; }

    private:
        const ConfigSistemaStages* config_;  // Non-owning pointer
--- a/source/game/title/ship_animator.cpp
+++ b/source/game/title/ship_animator.cpp
@@ -3,11 +3,13 @@

 #include "ship_animator.hpp"

+#include <algorithm>
 #include <cmath>

 #include "core/defaults.hpp"
 #include "core/graphics/shape_loader.hpp"
 #include "core/math/easing.hpp"
+#include "core/rendering/shape_renderer.hpp"

 namespace Title {

@@ -34,7 +36,9 @@ void ShipAnimator::inicialitzar() {
 void ShipAnimator::actualitzar(float delta_time) {
    // Dispatcher segons estat de cada nau
    for (auto& nau : naus_) {
-        if (!nau.visible) continue;
+        if (!nau.visible) {
+            continue;
+        }

        switch (nau.estat) {
            case EstatNau::ENTERING:
@@ -52,18 +56,20 @@ void ShipAnimator::actualitzar(float delta_time) {

 void ShipAnimator::dibuixar() const {
    for (const auto& nau : naus_) {
-        if (!nau.visible) continue;
+        if (!nau.visible) {
+            continue;
+        }

        // Renderitzar nau (perspectiva ja incorporada a la forma)
        Rendering::render_shape(
            renderer_,
            nau.forma,
            nau.posicio_actual,
-            0.0f,  // angle (rotació 2D no utilitzada)
+            0.0F,  // angle (rotació 2D no utilitzada)
            nau.escala_actual,
            true,  // dibuixar
-            1.0f,  // progress (sempre visible)
-            1.0f   // brightness (brillantor màxima)
+            1.0F,  // progress (sempre visible)
+            1.0F   // brightness (brillantor màxima)
        );
    }
 }
@@ -73,14 +79,14 @@ void ShipAnimator::start_entry_animation() {

    // Configurar nau P1 per a l'animació d'entrada
    naus_[0].estat = EstatNau::ENTERING;
-    naus_[0].temps_estat = 0.0f;
+    naus_[0].temps_estat = 0.0F;
    naus_[0].posicio_inicial = calcular_posicio_fora_pantalla(CLOCK_8_ANGLE);
    naus_[0].posicio_actual = naus_[0].posicio_inicial;
    naus_[0].escala_actual = naus_[0].escala_inicial;

    // Configurar nau P2 per a l'animació d'entrada
    naus_[1].estat = EstatNau::ENTERING;
-    naus_[1].temps_estat = 0.0f;
+    naus_[1].temps_estat = 0.0F;
    naus_[1].posicio_inicial = calcular_posicio_fora_pantalla(CLOCK_4_ANGLE);
    naus_[1].posicio_actual = naus_[1].posicio_inicial;
    naus_[1].escala_actual = naus_[1].escala_inicial;
@@ -91,7 +97,7 @@ void ShipAnimator::trigger_exit_animation() {
    for (auto& nau : naus_) {
        // Canviar estat a EXITING
        nau.estat = EstatNau::EXITING;
-        nau.temps_estat = 0.0f;
+        nau.temps_estat = 0.0F;

        // Preservar posició actual (pot estar a mig camí si START es prem durant ENTERING)
        nau.posicio_inicial = nau.posicio_actual;
@@ -105,8 +111,8 @@ void ShipAnimator::skip_to_floating_state() {
    // Posar ambdues naus directament en estat FLOATING
    for (auto& nau : naus_) {
        nau.estat = EstatNau::FLOATING;
-        nau.temps_estat = 0.0f;
-        nau.fase_oscilacio = 0.0f;
+        nau.temps_estat = 0.0F;
+        nau.fase_oscilacio = 0.0F;

        // Posar en posició objectiu (sense animació)
        nau.posicio_actual = nau.posicio_objectiu;
@@ -133,7 +139,7 @@ void ShipAnimator::trigger_exit_animation_for_player(int jugador_id) {
        if (nau.jugador_id == jugador_id) {
            // Canviar estat a EXITING només per aquesta nau
            nau.estat = EstatNau::EXITING;
-            nau.temps_estat = 0.0f;
+            nau.temps_estat = 0.0F;

            // Preservar posició actual (pot estar a mig camí si START es prem durant ENTERING)
            nau.posicio_inicial = nau.posicio_actual;
@@ -177,7 +183,7 @@ void ShipAnimator::actualitzar_entering(NauTitol& nau, float delta_time) {

    // Càlcul del progrés (restant el delay)
    float elapsed = nau.temps_estat - nau.entry_delay;
-    float progress = std::min(1.0f, elapsed / ENTRY_DURATION);
+    float progress = std::min(1.0F, elapsed / ENTRY_DURATION);

    // Aplicar easing (ease_out_quad per arribada suau)
    float eased_progress = Easing::ease_out_quad(progress);
@@ -192,8 +198,8 @@ void ShipAnimator::actualitzar_entering(NauTitol& nau, float delta_time) {
    // Transicionar a FLOATING quan completi
    if (elapsed >= ENTRY_DURATION) {
        nau.estat = EstatNau::FLOATING;
-        nau.temps_estat = 0.0f;
-        nau.fase_oscilacio = 0.0f;  // Reiniciar fase d'oscil·lació
+        nau.temps_estat = 0.0F;
+        nau.fase_oscilacio = 0.0F;  // Reiniciar fase d'oscil·lació
    }
 }

@@ -205,8 +211,8 @@ void ShipAnimator::actualitzar_floating(NauTitol& nau, float delta_time) {
    nau.fase_oscilacio += delta_time;

    // Oscil·lació sinusoïdal X/Y (paràmetres específics per nau)
-    float offset_x = nau.amplitude_x * std::sin(2.0f * Defaults::Math::PI * nau.frequency_x * nau.fase_oscilacio);
-    float offset_y = nau.amplitude_y * std::sin(2.0f * Defaults::Math::PI * nau.frequency_y * nau.fase_oscilacio + FLOAT_PHASE_OFFSET);
+    float offset_x = nau.amplitude_x * std::sin(2.0F * Defaults::Math::PI * nau.frequency_x * nau.fase_oscilacio);
+    float offset_y = nau.amplitude_y * std::sin((2.0F * Defaults::Math::PI * nau.frequency_y * nau.fase_oscilacio) + FLOAT_PHASE_OFFSET);

    // Aplicar oscil·lació a la posició objectiu
    nau.posicio_actual.x = nau.posicio_objectiu.x + offset_x;
@@ -222,13 +228,13 @@ void ShipAnimator::actualitzar_exiting(NauTitol& nau, float delta_time) {
    nau.temps_estat += delta_time;

    // Calcular progrés (0.0 → 1.0)
-    float progress = std::min(1.0f, nau.temps_estat / EXIT_DURATION);
+    float progress = std::min(1.0F, nau.temps_estat / EXIT_DURATION);

    // Aplicar easing (ease_in_quad per acceleració cap al punt de fuga)
    float eased_progress = Easing::ease_in_quad(progress);

    // Punt de fuga (centre del starfield)
-    constexpr Punt punt_fuga{VANISHING_POINT_X, VANISHING_POINT_Y};
+    constexpr Punt punt_fuga{.x = VANISHING_POINT_X, .y = VANISHING_POINT_Y};

    // Lerp posició cap al punt de fuga (preservar posició inicial actual)
    // Nota: posicio_inicial conté la posició on estava quan es va activar EXITING
@@ -236,10 +242,10 @@ void ShipAnimator::actualitzar_exiting(NauTitol& nau, float delta_time) {
    nau.posicio_actual.y = Easing::lerp(nau.posicio_inicial.y, punt_fuga.y, eased_progress);

    // Escala redueix a 0 (simula Z → infinit)
-    nau.escala_actual = nau.escala_objectiu * (1.0f - eased_progress);
+    nau.escala_actual = nau.escala_objectiu * (1.0F - eased_progress);

    // Marcar invisible quan l'animació completi
-    if (progress >= 1.0f) {
+    if (progress >= 1.0F) {
        nau.visible = false;
    }
 }
@@ -250,10 +256,10 @@ void ShipAnimator::configurar_nau_p1(NauTitol& nau) {

    // Estat inicial: FLOATING (per test estàtic)
    nau.estat = EstatNau::FLOATING;
-    nau.temps_estat = 0.0f;
+    nau.temps_estat = 0.0F;

    // Posicions (clock 8, bottom-left)
-    nau.posicio_objectiu = {P1_TARGET_X(), P1_TARGET_Y()};
+    nau.posicio_objectiu = {.x = P1_TARGET_X(), .y = P1_TARGET_Y()};

    // Calcular posició inicial (fora de pantalla)
    nau.posicio_inicial = calcular_posicio_fora_pantalla(CLOCK_8_ANGLE);
@@ -265,7 +271,7 @@ void ShipAnimator::configurar_nau_p1(NauTitol& nau) {
    nau.escala_inicial = ENTRY_SCALE_START;

    // Flotació
-    nau.fase_oscilacio = 0.0f;
+    nau.fase_oscilacio = 0.0F;

    // Paràmetres d'entrada
    nau.entry_delay = P1_ENTRY_DELAY;
@@ -285,10 +291,10 @@ void ShipAnimator::configurar_nau_p2(NauTitol& nau) {

    // Estat inicial: FLOATING (per test estàtic)
    nau.estat = EstatNau::FLOATING;
-    nau.temps_estat = 0.0f;
+    nau.temps_estat = 0.0F;

    // Posicions (clock 4, bottom-right)
-    nau.posicio_objectiu = {P2_TARGET_X(), P2_TARGET_Y()};
+    nau.posicio_objectiu = {.x = P2_TARGET_X(), .y = P2_TARGET_Y()};

    // Calcular posició inicial (fora de pantalla)
    nau.posicio_inicial = calcular_posicio_fora_pantalla(CLOCK_4_ANGLE);
@@ -300,7 +306,7 @@ void ShipAnimator::configurar_nau_p2(NauTitol& nau) {
    nau.escala_inicial = ENTRY_SCALE_START;

    // Flotació
-    nau.fase_oscilacio = 0.0f;
+    nau.fase_oscilacio = 0.0F;

    // Paràmetres d'entrada
    nau.entry_delay = P2_ENTRY_DELAY;
@@ -323,10 +329,10 @@ Punt ShipAnimator::calcular_posicio_fora_pantalla(float angle_rellotge) const {
    // ENTRY_OFFSET es calcula automàticament: (SHIP_MAX_RADIUS * ENTRY_SCALE_START) + ENTRY_OFFSET_MARGIN
    float extended_radius = CLOCK_RADIUS + ENTRY_OFFSET;

-    float x = Defaults::Game::WIDTH / 2.0f + extended_radius * std::cos(angle_rellotge);
-    float y = Defaults::Game::HEIGHT / 2.0f + extended_radius * std::sin(angle_rellotge);
+    float x = (Defaults::Game::WIDTH / 2.0F) + (extended_radius * std::cos(angle_rellotge));
+    float y = (Defaults::Game::HEIGHT / 2.0F) + (extended_radius * std::sin(angle_rellotge));

-    return {x, y};
+    return {.x = x, .y = y};
 }

 }  // namespace Title
--- a/source/game/title/ship_animator.hpp
+++ b/source/game/title/ship_animator.hpp
@@ -9,7 +9,6 @@
 #include <memory>

 #include "core/graphics/shape.hpp"
-#include "core/rendering/shape_renderer.hpp"
 #include "core/types.hpp"

 namespace Title {
@@ -77,8 +76,8 @@ class ShipAnimator {

        // Control de visibilitat
        void set_visible(bool visible);
-        bool is_animation_complete() const;
-        bool is_visible() const;  // Comprova si alguna nau és visible
+        [[nodiscard]] bool is_animation_complete() const;
+        [[nodiscard]] bool is_visible() const;  // Comprova si alguna nau és visible

    private:
        SDL_Renderer* renderer_;
@@ -92,7 +91,7 @@ class ShipAnimator {
        // Configuració
        void configurar_nau_p1(NauTitol& nau);
        void configurar_nau_p2(NauTitol& nau);
-        Punt calcular_posicio_fora_pantalla(float angle_rellotge) const;
+        [[nodiscard]] Punt calcular_posicio_fora_pantalla(float angle_rellotge) const;
 };

 }  // namespace Title
--- a/source/legacy/.clang-format
+++ b/source/legacy/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: Never
--- a/source/legacy/.clang-tidy
+++ b/source/legacy/.clang-tidy
@@ -0,0 +1,4 @@
+# source/external/.clang-tidy
+Checks: '-*'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
--- a/source/legacy/asteroids.cpp
+++ b/source/legacy/asteroids.cpp
@@ -59,14 +59,14 @@ std::vector<poligon> bales(MAX_BALES);
 virt : ^pvirt;

 procedure volca;
-var i : word;
+var i ; word;
 begin
     for i:=1 to 38400 do mem[$A000:i]:=mem[seg(virt^):i];
 end;

 procedure crear_poligon_regular(var pol : poligon; n : byte; r : real);
-var i : word;
-act, interval : real;
+var i ; word;
+act, interval ; real;
 aux : ipunt;
 begin {getmem(pol.ipunts,{n*464000);}
     interval:=2*pi/n;
--- a/tools/hooks/README.md
+++ b/tools/hooks/README.md
@@ -0,0 +1,249 @@
+# Git Hooks - Orni Attack
+
+Este directorio contiene los **git hooks** versionados para el proyecto Orni Attack.
+
+Los hooks permiten ejecutar automáticamente verificaciones de calidad de código antes de hacer commits.
+
+---
+
+## 📦 Instalación
+
+### Instalación automática (recomendada)
+
+Ejecuta el script de instalación desde la raíz del proyecto:
+
+```bash
+./tools/hooks/install.sh
+```
+
+### Instalación manual
+
+```bash
+cp tools/hooks/pre-commit .git/hooks/
+chmod +x .git/hooks/pre-commit
+```
+
+---
+
+## 🔍 Hooks disponibles
+
+### `pre-commit`
+
+**Se ejecuta automáticamente antes de cada commit.**
+
+Realiza dos verificaciones en los archivos `.cpp` y `.hpp` modificados:
+
+#### 1. 🎨 clang-format (formato de código)
+
+- **Acción**: Formatea automáticamente el código según `.clang-format`
+- **Comportamiento**: Si encuentra problemas de formato, los arregla automáticamente y añade los cambios al commit
+- **Resultado**: Código siempre bien formateado sin esfuerzo manual
+
+#### 2. 🔍 clang-tidy (análisis estático)
+
+- **Acción**: Verifica el código según las reglas de `.clang-tidy`
+- **Comportamiento**:
+  - ✅ Si no hay errores → commit permitido
+  - ❌ Si hay errores → commit **bloqueado** y muestra los errores
+- **Resultado**: Previene commits con problemas de calidad
+
+---
+
+## 📋 Ejemplo de uso
+
+```bash
+# 1. Modificas código
+vim source/game/entities/nau.cpp
+
+# 2. Añades al staging
+git add source/game/entities/nau.cpp
+
+# 3. Intentas commit
+git commit -m "feat: añadir nueva funcionalidad"
+
+# → El hook se ejecuta automáticamente:
+🔍 Pre-commit hook: verificando código...
+📝 Archivos a revisar: source/game/entities/nau.cpp
+
+🎨 Ejecutando clang-format...
+  ✏️  Formateado: source/game/entities/nau.cpp
+✅ Archivos formateados automáticamente y añadidos al commit
+
+🔍 Ejecutando clang-tidy...
+  ✅ source/game/entities/nau.cpp
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ Pre-commit hook: TODO OK
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  🎨 clang-format: OK (archivos formateados)
+  🔍 clang-tidy: OK (sin errores)
+
+[main abc1234] feat: añadir nueva funcionalidad
+ 1 file changed, 10 insertions(+)
+```
+
+---
+
+## ❌ ¿Qué pasa si hay errores?
+
+Si clang-tidy encuentra errores, el hook **bloquea el commit** y te muestra:
+
+```bash
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+❌ COMMIT BLOQUEADO: clang-tidy encontró errores
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+❌ Errores en source/game/entities/nau.cpp:
+source/game/entities/nau.cpp:42:10: error: method 'getPosition' can be made const
+      ^
+                                                                      const
+
+💡 Soluciones:
+  1. Corrige los errores manualmente
+  2. O ejecuta: make tidy (aplica fixes automáticos)
+  3. Luego: git add <archivos> && git commit
+
+⚠️  Si necesitas saltarte el hook (NO RECOMENDADO):
+  git commit --no-verify
+```
+
+### Soluciones
+
+**Opción 1: Arreglar manualmente**
+
+Edita el archivo y corrige los errores que muestra clang-tidy.
+
+**Opción 2: Auto-fix con make tidy**
+
+```bash
+make tidy              # Aplica fixes automáticos
+git add .              # Añade los cambios
+git commit -m "..."    # Intenta commit de nuevo
+```
+
+**Opción 3: Saltar el hook (NO RECOMENDADO)**
+
+```bash
+git commit --no-verify -m "mensaje"
+```
+
+⚠️ **Solo usa `--no-verify` en casos excepcionales**, ya que permite commits con código de baja calidad.
+
+---
+
+## 🚀 Ventajas
+
+✅ **Solo código nuevo**: Revisa únicamente archivos modificados (rápido)
+✅ **Automático**: No tienes que acordarte de ejecutar clang-tidy
+✅ **Formato automático**: clang-format arregla el código por ti
+✅ **Bloquea errores**: Previene commits con problemas de calidad
+✅ **No ralentiza compilación**: Solo se ejecuta en commits, no en `make`
+✅ **Excluye código externo**: Ignora automáticamente `audio/` y `legacy/`
+
+---
+
+## 🔧 Configuración
+
+Los hooks usan las configuraciones del proyecto:
+
+- **`.clang-format`**: Reglas de formato de código
+- **`.clang-tidy`**: Reglas de análisis estático
+- **`CMakeLists.txt`**: Exclusiones de directorios (audio/, legacy/)
+
+Si modificas estas configuraciones, los hooks aplicarán automáticamente las nuevas reglas.
+
+---
+
+## 🗑️ Desinstalación
+
+Para desinstalar el hook:
+
+```bash
+rm .git/hooks/pre-commit
+```
+
+O para deshabilitarlo temporalmente:
+
+```bash
+mv .git/hooks/pre-commit .git/hooks/pre-commit.disabled
+```
+
+Para volver a habilitarlo:
+
+```bash
+mv .git/hooks/pre-commit.disabled .git/hooks/pre-commit
+```
+
+---
+
+## 📚 Más información
+
+- **clang-format**: https://clang.llvm.org/docs/ClangFormat.html
+- **clang-tidy**: https://clang.llvm.org/extra/clang-tidy/
+- **Git hooks**: https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks
+
+---
+
+## ⚠️ Nota para desarrolladores
+
+Los hooks de git están en `.git/hooks/` y **no se versionan automáticamente**. Por eso este directorio `tools/hooks/` contiene copias versionadas que se pueden instalar fácilmente.
+
+**Cada nuevo desarrollador debe ejecutar el instalador** al clonar el repositorio:
+
+```bash
+git clone <repo-url>
+cd orni
+./tools/hooks/install.sh
+```
+
+---
+
+## 🐛 Troubleshooting
+
+### "clang-format: command not found"
+
+Instala clang-format:
+
+```bash
+# macOS
+brew install clang-format
+
+# Ubuntu/Debian
+sudo apt install clang-format
+
+# Arch Linux
+sudo pacman -S clang
+```
+
+### "clang-tidy: command not found"
+
+Instala clang-tidy:
+
+```bash
+# macOS
+brew install llvm
+export PATH="/opt/homebrew/opt/llvm/bin:$PATH"
+
+# Ubuntu/Debian
+sudo apt install clang-tidy
+
+# Arch Linux
+sudo pacman -S clang
+```
+
+### Hook no se ejecuta
+
+Verifica que el hook tiene permisos de ejecución:
+
+```bash
+ls -la .git/hooks/pre-commit
+chmod +x .git/hooks/pre-commit
+```
+
+### Errores en macOS sobre SDK
+
+El hook detecta automáticamente el SDK de macOS usando `xcrun --show-sdk-path`. Si falla, asegúrate de tener Command Line Tools instaladas:
+
+```bash
+xcode-select --install
+```
--- a/tools/hooks/install.sh
+++ b/tools/hooks/install.sh
@@ -0,0 +1,61 @@
+#!/bin/bash
+# Script de instalación de git hooks para desarrollo de Orni Attack
+# Copia los hooks desde tools/hooks/ a .git/hooks/ y los hace ejecutables
+
+set -e
+
+# Obtener raíz del repositorio
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || echo ".")
+
+# Colores para output
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "🔧 Instalando Git Hooks para Orni Attack"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+# Verificar que estamos en un repositorio git
+if [ ! -d "$REPO_ROOT/.git" ]; then
+    echo "❌ Error: No se encontró el directorio .git"
+    echo "   Ejecuta este script desde la raíz del repositorio"
+    exit 1
+fi
+
+# Verificar que existe el directorio de hooks versionados
+if [ ! -d "$REPO_ROOT/tools/hooks" ]; then
+    echo "❌ Error: No se encontró el directorio tools/hooks/"
+    exit 1
+fi
+
+# Instalar pre-commit hook
+if [ -f "$REPO_ROOT/tools/hooks/pre-commit" ]; then
+    echo "📦 Instalando pre-commit hook..."
+    cp "$REPO_ROOT/tools/hooks/pre-commit" "$REPO_ROOT/.git/hooks/pre-commit"
+    chmod +x "$REPO_ROOT/.git/hooks/pre-commit"
+    echo -e "   ${GREEN}✅ pre-commit instalado${NC}"
+else
+    echo -e "   ${YELLOW}⚠️  pre-commit no encontrado, saltando...${NC}"
+fi
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo -e "${GREEN}✅ Instalación completada${NC}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+echo "📋 Hooks instalados:"
+echo "   • pre-commit: Ejecuta clang-format + clang-tidy en cada commit"
+echo ""
+echo "💡 Próximos pasos:"
+echo "   1. Haz cambios en el código"
+echo "   2. git add <archivos>"
+echo "   3. git commit -m \"mensaje\""
+echo "   4. El hook verificará automáticamente tu código"
+echo ""
+echo "⚙️  Para desinstalar:"
+echo "   rm .git/hooks/pre-commit"
+echo ""
+
+exit 0
--- a/tools/hooks/pre-commit
+++ b/tools/hooks/pre-commit
@@ -0,0 +1,133 @@
+#!/bin/bash
+# Pre-commit hook: ejecuta clang-format y clang-tidy en archivos modificados
+# Para instalarlo: cp tools/hooks/pre-commit .git/hooks/ && chmod +x .git/hooks/pre-commit
+# O ejecuta: tools/hooks/install.sh
+
+set -e  # Salir si hay error
+
+echo "🔍 Pre-commit hook: verificando código..."
+
+# Obtener raíz del repositorio
+REPO_ROOT=$(git rev-parse --show-toplevel)
+
+# Obtener archivos staged (solo .cpp y .hpp)
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(cpp|hpp)$' || true)
+
+if [ -z "$STAGED_FILES" ]; then
+    echo "✅ No hay archivos C++ para revisar"
+    exit 0
+fi
+
+# Excluir directorios audio/ y legacy/ (igual que CMakeLists.txt)
+FILTERED_FILES=""
+for file in $STAGED_FILES; do
+    # Excluir si está en audio/ o legacy/
+    if [[ ! "$file" =~ audio/ ]] && [[ ! "$file" =~ legacy/ ]]; then
+        # Solo incluir si el archivo existe (no fue eliminado)
+        if [ -f "$file" ]; then
+            FILTERED_FILES="$FILTERED_FILES $file"
+        fi
+    fi
+done
+
+if [ -z "$FILTERED_FILES" ]; then
+    echo "✅ No hay archivos C++ para revisar (excluidos audio/ y legacy/)"
+    exit 0
+fi
+
+echo "📝 Archivos a revisar:$FILTERED_FILES"
+
+# ============================================
+# PASO 1: Ejecutar clang-format (auto-format)
+# ============================================
+echo ""
+echo "🎨 Ejecutando clang-format..."
+
+FORMAT_CHANGED=false
+for file in $FILTERED_FILES; do
+    # Ejecutar clang-format in-place
+    clang-format --style=file -i "$file"
+
+    # Verificar si el archivo cambió
+    if ! git diff --quiet "$file"; then
+        echo "  ✏️  Formateado: $file"
+        FORMAT_CHANGED=true
+        # Añadir cambios de formato al staging
+        git add "$file"
+    fi
+done
+
+if [ "$FORMAT_CHANGED" = true ]; then
+    echo "✅ Archivos formateados automáticamente y añadidos al commit"
+else
+    echo "✅ Formato correcto (sin cambios)"
+fi
+
+# ============================================
+# PASO 2: Ejecutar clang-tidy (verificación)
+# ============================================
+echo ""
+echo "🔍 Ejecutando clang-tidy..."
+
+# Configurar SDK de macOS (igual que CMakeLists.txt)
+MACOS_SDK=$(xcrun --show-sdk-path 2>/dev/null || echo "")
+
+TIDY_FAILED=false
+TIDY_OUTPUT=""
+
+for file in $FILTERED_FILES; do
+    # Ejecutar clang-tidy con configuración del proyecto
+    if [ -n "$MACOS_SDK" ]; then
+        TIDY_RESULT=$(clang-tidy "$file" \
+            --extra-arg=-std=c++20 \
+            --extra-arg=-isysroot"$MACOS_SDK" \
+            --extra-arg=-I"$REPO_ROOT"/source \
+            --extra-arg=-I"$REPO_ROOT"/build \
+            -- 2>&1 || echo "TIDY_ERROR")
+    else
+        TIDY_RESULT=$(clang-tidy "$file" \
+            --extra-arg=-std=c++20 \
+            --extra-arg=-I"$REPO_ROOT"/source \
+            --extra-arg=-I"$REPO_ROOT"/build \
+            -- 2>&1 || echo "TIDY_ERROR")
+    fi
+
+    # Verificar si hubo errores (ignorar warnings de headers del sistema)
+    ERROR_COUNT=$(echo "$TIDY_RESULT" | grep -E "error:|warning:" | grep -v "in non-user code" | wc -l | tr -d ' ')
+
+    if [ "$ERROR_COUNT" -gt 0 ]; then
+        TIDY_FAILED=true
+        TIDY_OUTPUT="$TIDY_OUTPUT\n\n❌ Errores en $file:\n$TIDY_RESULT"
+    else
+        echo "  ✅ $file"
+    fi
+done
+
+# Si clang-tidy encontró errores, bloquear commit
+if [ "$TIDY_FAILED" = true ]; then
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "❌ COMMIT BLOQUEADO: clang-tidy encontró errores"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo -e "$TIDY_OUTPUT"
+    echo ""
+    echo "💡 Soluciones:"
+    echo "  1. Corrige los errores manualmente"
+    echo "  2. O ejecuta: make tidy (aplica fixes automáticos)"
+    echo "  3. Luego: git add <archivos> && git commit"
+    echo ""
+    echo "⚠️  Si necesitas saltarte el hook (NO RECOMENDADO):"
+    echo "  git commit --no-verify"
+    echo ""
+    exit 1
+fi
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "✅ Pre-commit hook: TODO OK"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "  🎨 clang-format: OK (archivos formateados)"
+echo "  🔍 clang-tidy: OK (sin errores)"
+echo ""
+
+exit 0
--- a/tools/pack_resources/Makefile
+++ b/tools/pack_resources/Makefile
@@ -1,7 +1,7 @@
 # Makefile per a pack_resources
 # © 2025 Orni Attack

-CXX = clang++
+CXX ?= c++
 CXXFLAGS = -std=c++20 -Wall -Wextra -I../../source
 TARGET = pack_resources
Author	SHA1	Message	Date
Sergio Valor	fb394d23c9	corregit makefile de macos	2025-12-23 10:36:03 +01:00
Sergio Valor	1951bcad11	corregit makefile de windows	2025-12-23 10:03:32 +01:00
Sergio	9a874fc83b	corregit makefile de tools/pack_resources	2025-12-23 08:52:47 +01:00
Sergio	1acdd3f38d	corregit make linux_release	2025-12-23 08:18:13 +01:00
Sergio Valor	a2b11371cf	afegit include	2025-12-23 07:41:42 +01:00
Sergio Valor	b4b76ed6e8	afegit default per a fullscreen	2025-12-19 17:26:20 +01:00
Sergio Valor	6f4eb9c1fc	tidy: includes	2025-12-19 13:03:52 +01:00
Sergio Valor	47f7ffb169	feat: implementar jerarquia d'entitats amb classe base Entitat	2025-12-19 13:01:58 +01:00
Sergio Valor	70f2642e6d	feat(linter): afegir checks llvm-include-order i misc-include-cleaner - 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.	2025-12-18 22:35:46 +01:00
Sergio Valor	1a42f24a68	refactor(includes): convertir includes relativos a absolutos - escena_joc.hpp: 7 includes cambiados de ../ a rutas absolutas - pre-commit hook: añadir validación de includes relativos - Bloquea commits con includes tipo #include "../foo.hpp" - Coherencia con CMakeLists.txt (include_directories desde source/)	2025-12-18 22:24:17 +01:00
Sergio Valor	ac0f03c725	no compilava pack resources	2025-12-18 22:17:42 +01:00
Sergio Valor	1804c8a171	feat(tools): afegit pre-commit hook versionat (clang-format + clang-tidy) Sistema de git hooks per verificar qualitat de codi automàticament: Hooks implementats: - pre-commit: Executa clang-format + clang-tidy en arxius modificats - 🎨 clang-format: Formata automàticament el codi - 🔍 clang-tidy: Verifica errors i bloqueja commit si n'hi ha Característiques: - ✅ Només revisa arxius modificats (ràpid) - ✅ Auto-formata amb clang-format i afegeix canvis al commit - ✅ Bloqueja commits amb errors de clang-tidy - ✅ Exclou directoris audio/ i legacy/ automàticament - ✅ Rutes dinàmiques (funciona en qualsevol màquina) Instal·lació: ./tools/hooks/install.sh O manual: cp tools/hooks/pre-commit .git/hooks/ chmod +x .git/hooks/pre-commit Documentació completa: tools/hooks/README.md 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>	2025-12-18 22:08:44 +01:00
Sergio Valor	d83056c614	test: verificar pre-commit hook (clang-format + clang-tidy)	2025-12-18 22:04:34 +01:00
Sergio Valor	ba2a6fe914	refactor(linter): completat check 10 - bugprone-* (0 fixes necessaris) Check 10: bugprone-* - Detecció de bugs potencials Resultat: 0 fixes aplicats - tots els warnings eren falsos positius acceptables Warnings trobats i justificació d'exclusió: - bugprone-branch-clone: Fall-through en switch és intencional (patró del codi) - bugprone-switch-missing-default-case: No tots els switches necessiten default - bugprone-implicit-widening-of-multiplication-result: Valors petits, sense risc d'overflow - bugprone-exception-escape: Excepcions en main() terminen el programa (comportament acceptable) Estat final: ✅ Check 1: readability-uppercase-literal-suffix (657 fixes) ✅ Check 2: readability-math-missing-parentheses (291 fixes) ✅ Check 3: readability-identifier-naming (DESHABILITADO - cascada de cambios) ✅ Check 4: readability-const-return-type (0 fixes) ✅ Check 5: readability-else-after-return (0 fixes) ✅ Check 6: readability-simplify-boolean-expr (0 fixes) ✅ Check 7: readability-* (225 fixes) ✅ Check 8: modernize-* (215 fixes) ✅ Check 9: performance-* (91 fixes) ✅ Check 10: bugprone-* (0 fixes - falsos positius) Total: 1479 fixes aplicats correctament Compilació: ✅ OK Test del joc: ✅ OK 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>	2025-12-18 21:47:52 +01:00
Sergio Valor	364cf36183	perf: aplicar checks performance-* (91 fixes) Cambios aplicados: - Reemplazar std::endl con '\n' (91 casos) * std::endl hace flush del buffer (más lento) * '\n' solo inserta newline (más rápido) * Mejora rendimiento de logging/debug Check excluido: - performance-enum-size: Tamaño de enum no es crítico para rendimiento	2025-12-18 21:24:07 +01:00
Sergio Valor	7f6af6dd00	style: aplicar checks modernize-* (215 fixes) Cambios aplicados: - [[nodiscard]] añadido a funciones que retornan valores - .starts_with() en lugar de .find() == 0 - Inicializadores designados {.x=0, .y=0} - auto en castings obvios - = default para constructores triviales - Funciones deleted movidas a public - std::numbers::pi_v<float> (C++20) Checks excluidos: - use-trailing-return-type: Estilo controversial - avoid-c-arrays: Arrays C aceptables en ciertos contextos	2025-12-18 20:16:46 +01:00
Sergio Valor	fdfb84170f	style: aplicar todos los checks readability-* (225 fixes) Cambios aplicados: - readability-braces-around-statements (añadir llaves en ifs/fors) - readability-implicit-bool-conversion (puntero → bool explícito) - readability-container-size-empty (.empty() en lugar de .size()==0) - readability-container-contains (.contains() C++20) - readability-make-member-function-const (métodos const) - readability-else-after-return (5 casos adicionales) - Añadido #include <cmath> en defaults.hpp Checks excluidos (justificados): - identifier-naming: Cascada de 300+ cambios - identifier-length: Nombres cortos son OK en este proyecto - magic-numbers: Demasiados falsos positivos - convert-member-functions-to-static: Rompe encapsulación - use-anyofallof: C++20 ranges no universal - function-cognitive-complexity: Complejidad aceptable - clang-analyzer-security.insecureAPI.rand: rand() suficiente para juegos	2025-12-18 19:51:43 +01:00
Sergio Valor	2088ccdcc6	config(clang-tidy): check 6 completat + exclusió audio/legacy - Check 6 (readability-simplify-boolean-expr): No cal canvis - Deshabilitada temporalment check 3 (identifier-naming) per evitar cascada de 300+ canvis de nomenclatura - Exclosa source/core/audio/ i source/legacy/ dels targets de tidy (per evitar "no checks enabled" error)	2025-12-18 13:55:26 +01:00
Sergio Valor	7556c3fe8d	style: habilitar readability-else-after-return - Código ya cumple (no hay else innecesarios después de return) - Check 5/N completado 🤖 Generated with Claude Code	2025-12-18 13:32:42 +01:00
Sergio Valor	decde1b7d5	style: habilitar readability-const-return-type - Código ya cumple con el check (no hay const innecesarios en returns) - Check 4/N completado 🤖 Generated with Claude Code	2025-12-18 13:32:00 +01:00
Sergio Valor	c8545c712d	config(clang-tidy): excluir source/core/audio/ de análisis - Crear .clang-tidy local en source/core/audio/ con Checks: '-*' - Excluir jail_audio.hpp y archivos que dependen de él (código externo) - Ajustar HeaderFilterRegex en .clang-tidy raíz - Check 3 (readability-identifier-naming): código ya cumple convenciones 🤖 Generated with Claude Code	2025-12-18 13:26:27 +01:00
Sergio Valor	76786203a0	style: aplicar readability-math-missing-parentheses - Agregar paréntesis explícitos en operaciones matemáticas para claridad - Ejemplos: '1.0F - a * b' → '1.0F - (a * b)' - 291 correcciones aplicadas automáticamente con clang-tidy - Check 2/N completado 🤖 Generated with Claude Code	2025-12-18 13:09:35 +01:00
Sergio Valor	bc94eff176	style: aplicar readability-uppercase-literal-suffix - Cambiar todos los literales float de minúscula a mayúscula (1.0f → 1.0F) - 657 correcciones aplicadas automáticamente con clang-tidy - Check 1/N completado 🤖 Generated with Claude Code	2025-12-18 13:06:48 +01:00
Sergio Valor	44cd0857e0	fix(shape_loader): corregir inconsistencias de naming y static - Renombrar getCacheSize() → get_cache_size() (match con .hpp) - Renombrar resolvePath() → resolve_path() (match con .hpp) - Cambiar base_path → base_path_ (match con .hpp) - Eliminar 'static' de definiciones fuera de clase (error de C++)	2025-12-18 13:04:15 +01:00
Sergio Valor	f8521d644c	modificat cmake amb clang-tidy	2025-12-18 12:21:29 +01:00
Sergio Valor	eb2702eb19	afegit linter	2025-12-18 10:04:21 +01:00
Sergio Valor	bfb4903998	eliminat warning	2025-12-17 22:53:11 +01:00
Sergio Valor	f3abab7a13	augmentat numero de debris de 100 a 150 per necesitats del logo	2025-12-17 22:53:05 +01:00