correccions en el makefile de macos

afegit suppress a cppcheck
surface: hallazgo 1 — SurfaceData::width/height de float a int
2026-05-03 18:03:30 +02:00 · 2026-04-18 12:28:19 +02:00 · 2026-04-18 12:22:19 +02:00 · 2026-04-18 12:16:46 +02:00 · 2026-04-18 12:01:51 +02:00 · 2026-04-18 11:58:46 +02:00
37 changed files with 1148 additions and 687 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -2,29 +2,23 @@ Checks:
  - readability-*
  - modernize-*
  - performance-*
-  - bugprone-unchecked-optional-access
-  - bugprone-sizeof-expression
-  - bugprone-suspicious-missing-comma
-  - bugprone-suspicious-index
-  - bugprone-undefined-memory-manipulation
-  - bugprone-use-after-move
-  - bugprone-out-of-bound-access
+  - bugprone-*
  - -readability-identifier-length
  - -readability-magic-numbers
-  - -bugprone-narrowing-conversions
-  - -performance-enum-size
-  - -performance-inefficient-string-concatenation
  - -bugprone-integer-division
  - -bugprone-easily-swappable-parameters
+  - -bugprone-narrowing-conversions
  - -modernize-avoid-c-arrays,-warnings-as-errors

 WarningsAsErrors: '*'
-# Solo incluir archivos de tu código fuente (external tiene su propio .clang-tidy)
-# Excluye jail_audio.hpp del análisis
-HeaderFilterRegex: 'source/(?!core/audio/jail_audio\.hpp|core/rendering/sdl3gpu/.*_spv\.h).*'
+# Solo headers del propio código fuente (external/ y spv/ tienen su propio .clang-tidy dummy)
+HeaderFilterRegex: 'source/.*'
 FormatStyle: file

 CheckOptions:
+  # bugprone-empty-catch: aceptar catches vacíos marcados con @INTENTIONAL en un comentario
+  - { key: bugprone-empty-catch.IgnoreCatchWithKeywords, value: '@INTENTIONAL' }
+
  # Variables locales en snake_case
  - { key: readability-identifier-naming.VariableCase, value: lower_case }

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,6 +3,11 @@
 cmake_minimum_required(VERSION 3.10)
 project(jaildoctors_dilemma VERSION 1.00)

+# Tipus de build per defecte (Debug) si no se n'ha especificat cap
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+    set(CMAKE_BUILD_TYPE Debug CACHE STRING "" FORCE)
+endif()
+
 # Establecer estándar de C++
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
@@ -11,17 +16,24 @@ set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

 # --- GENERACIÓN DE VERSIÓN AUTOMÁTICA ---
-find_package(Git QUIET)
-if(GIT_FOUND)
-    execute_process(
-        COMMAND ${GIT_EXECUTABLE} rev-parse --short=7 HEAD
-        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-        OUTPUT_VARIABLE GIT_HASH
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-        ERROR_QUIET
-    )
-else()
-    set(GIT_HASH "unknown")
+# Si GIT_HASH se ha pasado desde fuera (p.ej. desde el Makefile via -DGIT_HASH=xxx),
+# lo usamos tal cual. Esto evita problemas con Docker/emscripten, donde git aborta por
+# "dubious ownership" en el volumen montado. En builds locales sin -DGIT_HASH, se
+# resuelve aquí ejecutando git directamente.
+if(NOT DEFINED GIT_HASH OR GIT_HASH STREQUAL "")
+    find_package(Git QUIET)
+    if(GIT_FOUND)
+        execute_process(
+            COMMAND ${GIT_EXECUTABLE} rev-parse --short=7 HEAD
+            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+            OUTPUT_VARIABLE GIT_HASH
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            ERROR_QUIET
+        )
+    endif()
+    if(NOT DEFINED GIT_HASH OR GIT_HASH STREQUAL "")
+        set(GIT_HASH "unknown")
+    endif()
 endif()

 # Configurar archivo de versión
@@ -31,6 +43,7 @@ configure_file(${CMAKE_SOURCE_DIR}/source/version.h.in ${CMAKE_BINARY_DIR}/versi
 set(APP_SOURCES
    # Core - Audio
    source/core/audio/audio.cpp
+    source/core/audio/audio_adapter.cpp

    # Core - Input
    source/core/input/global_inputs.cpp
@@ -134,7 +147,7 @@ if(EMSCRIPTEN)
    FetchContent_Declare(
        SDL3
        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
-        GIT_TAG release-3.2.12
+        GIT_TAG release-3.4.4
        GIT_SHALLOW TRUE
    )
    set(SDL_SHARED OFF CACHE BOOL "" FORCE)
@@ -152,7 +165,7 @@ if(NOT APPLE AND NOT EMSCRIPTEN)
    find_program(GLSLC_EXE NAMES glslc)

    set(SHADERS_DIR "${CMAKE_SOURCE_DIR}/data/shaders")
-    set(HEADERS_DIR "${CMAKE_SOURCE_DIR}/source/core/rendering/sdl3gpu")
+    set(HEADERS_DIR "${CMAKE_SOURCE_DIR}/source/core/rendering/sdl3gpu/spv")

    set(SHADER_POSTFX_VERT_SRC  "${SHADERS_DIR}/postfx.vert")
    set(SHADER_POSTFX_FRAG_SRC  "${SHADERS_DIR}/postfx.frag")
@@ -297,6 +310,7 @@ endif()
 # Buscar herramientas de análisis estático
 find_program(CLANG_TIDY_EXE NAMES clang-tidy)
 find_program(CLANG_FORMAT_EXE NAMES clang-format)
+find_program(CPPCHECK_EXE NAMES cppcheck)

 # Recopilar todos los archivos fuente para formateo
 file(GLOB_RECURSE ALL_SOURCE_FILES
@@ -308,10 +322,11 @@ file(GLOB_RECURSE ALL_SOURCE_FILES
 # Excluir directorio external del análisis
 list(FILTER ALL_SOURCE_FILES EXCLUDE REGEX ".*/external/.*")

-# Para clang-tidy, también excluir jail_audio.hpp
 set(CLANG_TIDY_SOURCES ${ALL_SOURCE_FILES})
-list(FILTER CLANG_TIDY_SOURCES EXCLUDE REGEX ".*jail_audio\\.hpp$")
-list(FILTER CLANG_TIDY_SOURCES EXCLUDE REGEX ".*_spv\\.h$")
+
+# Para cppcheck, pasar solo .cpp (los headers se procesan transitivamente).
+set(CPPCHECK_SOURCES ${ALL_SOURCE_FILES})
+list(FILTER CPPCHECK_SOURCES INCLUDE REGEX ".*\\.cpp$")

 # Targets de clang-tidy
 if(CLANG_TIDY_EXE)
@@ -357,31 +372,55 @@ else()
    message(STATUS "clang-format no encontrado - targets 'format' y 'format-check' no disponibles")
 endif()

-# --- 6. PACK RESOURCES TARGETS (no en Emscripten: s'utilitza --preload-file) ---
+# Target de cppcheck
+if(CPPCHECK_EXE)
+    add_custom_target(cppcheck
+        COMMAND ${CPPCHECK_EXE}
+            --enable=warning,style,performance,portability
+            --std=c++20
+            --language=c++
+            --inline-suppr
+            --suppress=missingIncludeSystem
+            --suppress=toomanyconfigs
+            --suppress=*:*/source/external/*
+            --suppress=*:*/source/core/rendering/sdl3gpu/spv/*
+            --quiet
+            -I ${CMAKE_SOURCE_DIR}/source
+            ${CPPCHECK_SOURCES}
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Running cppcheck..."
+    )
+else()
+    message(STATUS "cppcheck no encontrado - target 'cppcheck' no disponible")
+endif()
+
+# --- 6. EINA STANDALONE: pack_resources (no en Emscripten: s'utilitza --preload-file) ---
+# Executable auxiliar que empaqueta `data/` a `resources.pack`.
+# No es compila per defecte (EXCLUDE_FROM_ALL). Build explícit:
+#   cmake --build build --target pack_resources
 if(NOT EMSCRIPTEN)
-    set(PACK_TOOL_SOURCES
-        ${CMAKE_SOURCE_DIR}/tools/pack_resources/pack_resources.cpp
-        ${CMAKE_SOURCE_DIR}/source/core/resources/resource_pack.cpp
+    add_executable(pack_resources EXCLUDE_FROM_ALL
+        tools/pack_resources/pack_resources.cpp
+        source/core/resources/resource_pack.cpp
    )
+    target_include_directories(pack_resources PRIVATE "${CMAKE_SOURCE_DIR}/source")
+    target_compile_options(pack_resources PRIVATE -Wall)

-    add_executable(pack_tool ${PACK_TOOL_SOURCES})
-    target_include_directories(pack_tool PRIVATE ${CMAKE_SOURCE_DIR}/source)
-    set_target_properties(pack_tool PROPERTIES
-        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/tools/pack_resources
-    )
-
-    file(GLOB_RECURSE DATA_FILES "${CMAKE_SOURCE_DIR}/data/*")
+    # Regeneració automàtica de resources.pack en cada build si canvia data/.
+    file(GLOB_RECURSE DATA_FILES CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/data/*")
+    set(RESOURCE_PACK "${CMAKE_SOURCE_DIR}/resources.pack")

    add_custom_command(
-        OUTPUT  "${CMAKE_SOURCE_DIR}/resources.pack"
-        COMMAND $<TARGET_FILE:pack_tool>
-                "${CMAKE_SOURCE_DIR}/data"
-                "${CMAKE_SOURCE_DIR}/resources.pack"
-        DEPENDS pack_tool ${DATA_FILES}
-        WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-        COMMENT "Generando resources.pack desde data/..."
+        OUTPUT ${RESOURCE_PACK}
+        COMMAND $<TARGET_FILE:pack_resources>
+            "${CMAKE_SOURCE_DIR}/data"
+            "${RESOURCE_PACK}"
+        DEPENDS pack_resources ${DATA_FILES}
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Empaquetant data/ → resources.pack"
+        VERBATIM
    )

-    add_custom_target(pack DEPENDS "${CMAKE_SOURCE_DIR}/resources.pack")
-    add_dependencies(${PROJECT_NAME} pack)
+    add_custom_target(resource_pack ALL DEPENDS ${RESOURCE_PACK})
+    add_dependencies(${PROJECT_NAME} resource_pack)
 endif()
--- a/218
+++ b/218
@@ -4,7 +4,6 @@
 DIR_ROOT       := $(dir $(abspath $(MAKEFILE_LIST)))
 DIR_SOURCES    := $(addsuffix /, $(DIR_ROOT)source)
 DIR_BIN        := $(addsuffix /, $(DIR_ROOT))
-DIR_TOOLS      := $(addsuffix /, $(DIR_ROOT)tools)

 # ==============================================================================
 # TARGET NAMES
@@ -20,8 +19,6 @@ RESOURCE_FILE  := release/windows/jdd.res
 # ==============================================================================
 # TOOLS
 # ==============================================================================
-DIR_PACK_TOOL  := $(DIR_TOOLS)pack_resources
-SHADER_SCRIPT  := $(DIR_ROOT)tools/shaders/compile_spirv.sh
 SHADER_CMAKE   := $(DIR_ROOT)tools/shaders/compile_spirv.cmake
 SHADERS_DIR    := $(DIR_ROOT)data/shaders
 HEADERS_DIR    := $(DIR_ROOT)source/core/rendering/sdl3gpu
@@ -35,9 +32,23 @@ endif
 # VERSION (extracted from defines.hpp)
 # ==============================================================================
 ifeq ($(OS),Windows_NT)
-    VERSION := v$(shell powershell -Command "(Select-String -Path 'source/utils/defines.hpp' -Pattern 'constexpr const char\* VERSION = \"(.+?)\"').Matches.Groups[1].Value")
+    VERSION := $(shell powershell -Command "(Select-String -Path 'source/utils/defines.hpp' -Pattern 'constexpr const char\* VERSION = \"(.+?)\"').Matches.Groups[1].Value")
 else
-    VERSION := v$(shell grep 'constexpr const char\* VERSION' source/utils/defines.hpp | sed -E 's/.*VERSION = "([^"]+)".*/\1/')
+    VERSION := $(shell grep 'constexpr const char\* VERSION' source/utils/defines.hpp | sed -E 's/.*VERSION = "([^"]+)".*/\1/')
+endif
+
+# ==============================================================================
+# GIT HASH (computat al host, passat a CMake via -DGIT_HASH)
+# Evita que CMake haja de cridar git des de Docker/emscripten on falla per
+# "dubious ownership" del volum muntat.
+# ==============================================================================
+ifeq ($(OS),Windows_NT)
+    GIT_HASH := $(shell git rev-parse --short=7 HEAD 2>NUL)
+else
+    GIT_HASH := $(shell git rev-parse --short=7 HEAD 2>/dev/null)
+endif
+ifeq ($(GIT_HASH),)
+    GIT_HASH := unknown
 endif

 # ==============================================================================
@@ -84,15 +95,24 @@ else
    UNAME_S         := $(shell uname -s)
 endif

+# ==============================================================================
+# CMAKE GENERATOR (Windows needs explicit MinGW Makefiles generator)
+# ==============================================================================
+ifeq ($(OS),Windows_NT)
+    CMAKE_GEN := -G "MinGW Makefiles"
+else
+    CMAKE_GEN :=
+endif
+
 # ==============================================================================
 # COMPILACIÓN CON CMAKE
 # ==============================================================================
 all:
-	@cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+	@cmake $(CMAKE_GEN) -S . -B build -DCMAKE_BUILD_TYPE=Release -DGIT_HASH=$(GIT_HASH)
 	@cmake --build build

 debug:
-	@cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
+	@cmake $(CMAKE_GEN) -S . -B build -DCMAKE_BUILD_TYPE=Debug -DGIT_HASH=$(GIT_HASH)
 	@cmake --build build

 # ==============================================================================
@@ -100,12 +120,12 @@ debug:
 # ==============================================================================
 release:
 ifeq ($(OS),Windows_NT)
-	@"$(MAKE)" windows_release
+	@"$(MAKE)" _windows_release
 else
 ifeq ($(UNAME_S),Darwin)
-	@$(MAKE) macos_release
+	@$(MAKE) _macos_release
 else
-	@$(MAKE) linux_release
+	@$(MAKE) _linux_release
 endif
 endif

@@ -120,23 +140,22 @@ else
 endif

 # ==============================================================================
-# REGLAS PARA HERRAMIENTA DE EMPAQUETADO Y RESOURCES.PACK
+# EMPAQUETADO DE RECURSOS (build previ de l'eina + execució)
 # ==============================================================================
-pack_tool:
-	@$(MAKE) -C $(DIR_PACK_TOOL)
-
-resources.pack: pack_tool
-	@$(MAKE) -C $(DIR_PACK_TOOL) pack
+pack:
+	@cmake $(CMAKE_GEN) -S . -B build -DCMAKE_BUILD_TYPE=Release -DGIT_HASH=$(GIT_HASH)
+	@cmake --build build --target pack_resources
+	@./build/pack_resources data resources.pack

 # ==============================================================================
 # COMPILACIÓN PARA WINDOWS (RELEASE)
 # ==============================================================================
-windows_release:
+_windows_release:
 	@echo off
 	@echo Creando release para Windows - Version: $(VERSION)

 # Compila con cmake (genera shaders, resources.pack y ejecutable)
-	@cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+	@cmake $(CMAKE_GEN) -S . -B build -DCMAKE_BUILD_TYPE=Release -DGIT_HASH=$(GIT_HASH)
 	@cmake --build build

 # Crea carpeta de distribución y carpeta temporal 'RELEASE_FOLDER'
@@ -164,15 +183,31 @@ windows_release:
 # ==============================================================================
 # COMPILACIÓN PARA MACOS (RELEASE)
 # ==============================================================================
-macos_release:
+_macos_release:
 	@echo "Creando release para macOS - Version: $(VERSION)"

-# Verificar e instalar create-dmg si es necesario
-	@which create-dmg > /dev/null || (echo "Instalando create-dmg..." && brew install create-dmg)
-
-# Compila la versión para procesadores Intel con cmake (genera shaders y resources.pack)
-	@cmake -S . -B build/intel -DCMAKE_BUILD_TYPE=Release -DCMAKE_OSX_ARCHITECTURES=x86_64 -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15 -DMACOS_BUNDLE=ON
-	@cmake --build build/intel
+# Verifica dependencias necesarias (create-dmg). Si falta, intenta instalarla
+# con brew; si brew tampoco está, indica el comando exacto al usuario.
+	@command -v create-dmg >/dev/null 2>&1 || { \
+		echo ""; \
+		echo "============================================"; \
+		echo "  Falta la dependencia: create-dmg"; \
+		echo "============================================"; \
+		if command -v brew >/dev/null 2>&1; then \
+			echo "  Instalando con: brew install create-dmg"; \
+			brew install create-dmg || { \
+				echo ""; \
+				echo "  ERROR: 'brew install create-dmg' ha fallado."; \
+				echo "  Ejecuta el comando manualmente y vuelve a probar."; \
+				exit 1; \
+			}; \
+		else \
+			echo "  Homebrew no está instalado."; \
+			echo "  Instálalo desde https://brew.sh y luego ejecuta:"; \
+			echo "      brew install create-dmg"; \
+			exit 1; \
+		fi; \
+	}

 # Elimina datos de compilaciones anteriores
 	$(RMDIR) "$(RELEASE_FOLDER)"
@@ -186,12 +221,11 @@ macos_release:
 	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS"
 	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"

-# Copia carpetas y ficheros
-	cp resources.pack "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
-	cp gamecontrollerdb.txt "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
+# Copia carpetas y ficheros del bundle (resources.pack se generará al compilar)
 	cp -R release/macos/frameworks/SDL3.xcframework/macos-arm64_x86_64/SDL3.framework "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks"
 	cp release/icons/*.icns "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
 	cp release/macos/Info.plist "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents"
+	cp gamecontrollerdb.txt "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
 	cp LICENSE "$(RELEASE_FOLDER)"
 	cp README.md "$(RELEASE_FOLDER)"

@@ -201,32 +235,53 @@ macos_release:
 	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"

-# Copia el ejecutable Intel al bundle
-	cp "$(TARGET_FILE)" "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_NAME)"
-
-# Firma la aplicación
-	codesign --deep --force --sign - --timestamp=none "$(RELEASE_FOLDER)/$(APP_NAME).app"
-
-# Empaqueta el .dmg de la versión Intel con create-dmg
-	@echo "Creando DMG Intel con iconos de 96x96..."
-	create-dmg \
-	  --volname "$(APP_NAME)" \
-	  --window-pos 200 120 \
-	  --window-size 720 300 \
-	  --icon-size 96 \
-	  --text-size 12 \
-	  --icon "$(APP_NAME).app" 278 102 \
-	  --icon "LICENSE" 441 102 \
-	  --icon "README.md" 604 102 \
-	  --app-drop-link 115 102 \
-	  --hide-extension "$(APP_NAME).app" \
-	  "$(MACOS_INTEL_RELEASE)" \
-	  "$(RELEASE_FOLDER)" || true
-	@echo "Release Intel creado: $(MACOS_INTEL_RELEASE)"
+# Compila y empaqueta la versión Intel (best-effort: si falla, se omite el
+# DMG Intel y continúa con la build de Apple Silicon).
+	@echo ""
+	@echo "============================================"
+	@echo "  Compilando version Intel (x86_64)"
+	@echo "============================================"
+	@if cmake -S . -B build/intel -DCMAKE_BUILD_TYPE=Release \
+	          -DCMAKE_OSX_ARCHITECTURES=x86_64 \
+	          -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15 \
+	          -DMACOS_BUNDLE=ON -DGIT_HASH=$(GIT_HASH) \
+	   && cmake --build build/intel; then \
+		cp resources.pack "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"; \
+		cp "$(TARGET_FILE)" "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_NAME)"; \
+		codesign --deep --force --sign - --timestamp=none "$(RELEASE_FOLDER)/$(APP_NAME).app"; \
+		echo "Creando DMG Intel con iconos de 96x96..."; \
+		create-dmg \
+		  --volname "$(APP_NAME)" \
+		  --window-pos 200 120 \
+		  --window-size 720 300 \
+		  --icon-size 96 \
+		  --text-size 12 \
+		  --icon "$(APP_NAME).app" 278 102 \
+		  --icon "LICENSE" 441 102 \
+		  --icon "README.md" 604 102 \
+		  --app-drop-link 115 102 \
+		  --hide-extension "$(APP_NAME).app" \
+		  "$(MACOS_INTEL_RELEASE)" \
+		  "$(RELEASE_FOLDER)" || true; \
+		echo "Release Intel creado: $(MACOS_INTEL_RELEASE)"; \
+	else \
+		echo ""; \
+		echo "============================================"; \
+		echo "  WARNING: la build Intel ha fallado."; \
+		echo "  Se omite el DMG Intel y se continúa con"; \
+		echo "  la build de Apple Silicon."; \
+		echo "============================================"; \
+		echo ""; \
+	fi

 # Compila la versión para procesadores Apple Silicon con cmake
-	@cmake -S . -B build/arm -DCMAKE_BUILD_TYPE=Release -DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 -DMACOS_BUNDLE=ON
+	@echo ""
+	@echo "============================================"
+	@echo "  Compilando version Apple Silicon (arm64)"
+	@echo "============================================"
+	@cmake -S . -B build/arm -DCMAKE_BUILD_TYPE=Release -DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 -DMACOS_BUNDLE=ON -DGIT_HASH=$(GIT_HASH)
 	@cmake --build build/arm
+	cp resources.pack "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
 	cp "$(TARGET_FILE)" "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_NAME)"

 # Firma la aplicación
@@ -258,11 +313,11 @@ macos_release:
 # ==============================================================================
 # COMPILACIÓN PARA LINUX (RELEASE)
 # ==============================================================================
-linux_release:
+_linux_release:
 	@echo "Creando release para Linux - Version: $(VERSION)"

 # Compila con cmake (genera shaders, resources.pack y ejecutable)
-	@cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+	@cmake $(CMAKE_GEN) -S . -B build -DCMAKE_BUILD_TYPE=Release -DGIT_HASH=$(GIT_HASH)
 	@cmake --build build

 # Elimina carpeta temporal previa y la recrea (crea dist/ si no existe)
@@ -291,16 +346,21 @@ linux_release:
 wasm:
 	@echo "Compilando para WebAssembly - Version: $(VERSION)"
 	docker run --rm \
+		--user $(shell id -u):$(shell id -g) \
 		-v $(DIR_ROOT):/src \
 		-w /src \
 		emscripten/emsdk:latest \
-		bash -c "emcmake cmake -S . -B build/wasm -DCMAKE_BUILD_TYPE=Release && cmake --build build/wasm"
+		bash -c "emcmake cmake -S . -B build/wasm -DCMAKE_BUILD_TYPE=Release -DGIT_HASH=$(GIT_HASH) && cmake --build build/wasm"
 	$(MKDIR) "$(DIST_DIR)/wasm"
 	cp build/wasm/$(TARGET_NAME).html $(DIST_DIR)/wasm/
 	cp build/wasm/$(TARGET_NAME).js $(DIST_DIR)/wasm/
 	cp build/wasm/$(TARGET_NAME).wasm $(DIST_DIR)/wasm/
 	cp build/wasm/$(TARGET_NAME).data $(DIST_DIR)/wasm/
 	@echo "Output: $(DIST_DIR)/wasm/"
+	scp $(DIST_DIR)/wasm/$(TARGET_NAME).js $(DIST_DIR)/wasm/$(TARGET_NAME).wasm $(DIST_DIR)/wasm/$(TARGET_NAME).data \
+		maverick:/home/sergio/gitea/web_jailgames/static/games/jaildoctors-dilemma/wasm/
+	ssh maverick 'cd /home/sergio/gitea/web_jailgames && ./deploy.sh'
+	@echo "Deployed to maverick"

 # Versió Debug del build wasm: arrenca directament a la GAME (sense logo/loading/title)
 # i activa l'editor i la consola. Sortida a dist/wasm_debug/.
@@ -310,7 +370,7 @@ wasm_debug:
 		-v $(DIR_ROOT):/src \
 		-w /src \
 		emscripten/emsdk:latest \
-		bash -c "emcmake cmake -S . -B build/wasm_debug -DCMAKE_BUILD_TYPE=Debug && cmake --build build/wasm_debug"
+		bash -c "emcmake cmake -S . -B build/wasm_debug -DCMAKE_BUILD_TYPE=Debug -DGIT_HASH=$(GIT_HASH) && cmake --build build/wasm_debug"
 	$(MKDIR) "$(DIST_DIR)/wasm_debug"
 	cp build/wasm_debug/$(TARGET_NAME).html $(DIST_DIR)/wasm_debug/
 	cp build/wasm_debug/$(TARGET_NAME).js $(DIST_DIR)/wasm_debug/
@@ -318,6 +378,38 @@ wasm_debug:
 	cp build/wasm_debug/$(TARGET_NAME).data $(DIST_DIR)/wasm_debug/
 	@echo "Output: $(DIST_DIR)/wasm_debug/"

+# ==============================================================================
+# ==============================================================================
+# CODE QUALITY (delegados a cmake)
+# ==============================================================================
+format:
+	@cmake $(CMAKE_GEN) -S . -B build -DCMAKE_BUILD_TYPE=Release -DGIT_HASH=$(GIT_HASH)
+	@cmake --build build --target format
+
+format-check:
+	@cmake $(CMAKE_GEN) -S . -B build -DCMAKE_BUILD_TYPE=Release -DGIT_HASH=$(GIT_HASH)
+	@cmake --build build --target format-check
+
+tidy:
+	@cmake $(CMAKE_GEN) -S . -B build -DCMAKE_BUILD_TYPE=Release -DGIT_HASH=$(GIT_HASH)
+	@cmake --build build --target tidy
+
+tidy-fix:
+	@cmake $(CMAKE_GEN) -S . -B build -DCMAKE_BUILD_TYPE=Release -DGIT_HASH=$(GIT_HASH)
+	@cmake --build build --target tidy-fix
+
+cppcheck:
+	@cmake $(CMAKE_GEN) -S . -B build -DCMAKE_BUILD_TYPE=Release -DGIT_HASH=$(GIT_HASH)
+	@cmake --build build --target cppcheck
+
+# DESCARGA DE GAMECONTROLLERDB
+# ==============================================================================
+controllerdb:
+	@echo "Descargando gamecontrollerdb.txt..."
+	curl -fsSL https://raw.githubusercontent.com/mdqinc/SDL_GameControllerDB/master/gamecontrollerdb.txt \
+		-o gamecontrollerdb.txt
+	@echo "gamecontrollerdb.txt actualizado"
+
 # ==============================================================================
 # REGLAS ESPECIALES
 # ==============================================================================
@@ -336,19 +428,23 @@ help:
 	@echo ""
 	@echo "  Release:"
 	@echo "    make release         - Crear release (detecta SO automaticamente)"
-	@echo "    make windows_release - Crear release para Windows"
-	@echo "    make linux_release   - Crear release para Linux"
-	@echo "    make macos_release   - Crear release para macOS"
 	@echo "    make wasm            - Crear release per a WebAssembly (requereix Docker)"
 	@echo "    make wasm_debug      - Crear build Debug per a WebAssembly (entra directe a la GAME)"
 	@echo ""
 	@echo "  Herramientas:"
 	@echo "    make compile_shaders - Compilar shaders SPIR-V"
-	@echo "    make pack_tool       - Compilar herramienta de empaquetado"
-	@echo "    make resources.pack  - Generar pack de recursos desde data/"
+	@echo "    make pack            - Empaquetar recursos a resources.pack"
+	@echo "    make controllerdb    - Descargar gamecontrollerdb.txt actualizado"
+	@echo ""
+	@echo "  Calidad de codigo:"
+	@echo "    make format          - Formatear codigo con clang-format"
+	@echo "    make format-check    - Verificar formato sin modificar"
+	@echo "    make tidy            - Analisis estatico con clang-tidy"
+	@echo "    make tidy-fix        - Analisis estatico con auto-fix"
+	@echo "    make cppcheck        - Analisis estatico con cppcheck"
 	@echo ""
 	@echo "  Otros:"
 	@echo "    make show_version    - Mostrar version actual ($(VERSION))"
 	@echo "    make help            - Mostrar esta ayuda"

-.PHONY: all debug release windows_release macos_release linux_release wasm wasm_debug compile_shaders pack_tool resources.pack show_version help
+.PHONY: all debug release _windows_release _macos_release _linux_release wasm wasm_debug compile_shaders pack controllerdb format format-check tidy tidy-fix cppcheck show_version help
--- a/gamecontrollerdb.txt
+++ b/gamecontrollerdb.txt
--- a/source/core/audio/audio.cpp
+++ b/source/core/audio/audio.cpp
@@ -1,19 +1,27 @@
-#include "audio.hpp"
+#include "core/audio/audio.hpp"

-#include <SDL3/SDL.h>  // Para SDL_LogInfo, SDL_LogCategory, SDL_G...
+#include <SDL3/SDL.h>  // Para SDL_GetError, SDL_Init

 #include <algorithm>  // Para clamp
 #include <iostream>   // Para std::cout

-// Implementación de stb_vorbis (debe estar ANTES de incluir jail_audio.hpp)
+// Implementación de stb_vorbis (debe estar ANTES de incluir jail_audio.hpp).
 // clang-format off
 #undef STB_VORBIS_HEADER_ONLY
-#include "external/stb_vorbis.h"
+#include "external/stb_vorbis.c"
+// stb_vorbis.c filtra les macros L, C i R (i PLAYBACK_*) al TU. Les netegem
+// perquè xocarien amb noms de paràmetres de plantilla en altres headers.
+#undef L
+#undef C
+#undef R
+#undef PLAYBACK_MONO
+#undef PLAYBACK_LEFT
+#undef PLAYBACK_RIGHT
 // clang-format on

-#include "core/audio/jail_audio.hpp"          // Para JA_FadeOutMusic, JA_Init, JA_PauseM...
-#include "core/resources/resource_cache.hpp"  // Para Resource
-#include "game/options.hpp"                   // Para AudioOptions, audio, MusicOptions
+#include "core/audio/audio_adapter.hpp"  // Para AudioResource::getMusic/getSound
+#include "core/audio/jail_audio.hpp"     // Para JA_*
+#include "game/options.hpp"              // Para Options::audio

 // Singleton
 Audio* Audio::instance = nullptr;
@@ -22,7 +30,10 @@ Audio* Audio::instance = nullptr;
 void Audio::init() { Audio::instance = new Audio(); }

 // Libera la instancia
-void Audio::destroy() { delete Audio::instance; }
+void Audio::destroy() {
+    delete Audio::instance;
+    Audio::instance = nullptr;
+}

 // Obtiene la instancia
 auto Audio::get() -> Audio* { return Audio::instance; }
@@ -38,10 +49,15 @@ Audio::~Audio() {
 // Método principal
 void Audio::update() {
    JA_Update();
+
+    // Sincronizar estado: detectar cuando la música se para (ej. fade-out completado)
+    if (instance && instance->music_.state == MusicState::PLAYING && JA_GetMusicState() != JA_MUSIC_PLAYING) {
+        instance->music_.state = MusicState::STOPPED;
+    }
 }

-// Reproduce la música
-void Audio::playMusic(const std::string& name, const int loop) {  // NOLINT(readability-convert-member-functions-to-static)
+// Reproduce la música por nombre (con crossfade opcional)
+void Audio::playMusic(const std::string& name, const int loop, const int crossfade_ms) {
    bool new_loop = (loop != 0);

    // Si ya está sonando exactamente la misma pista y mismo modo loop, no hacemos nada
@@ -49,29 +65,45 @@ void Audio::playMusic(const std::string& name, const int loop) {  // NOLINT(read
        return;
    }

-    // Intentar obtener recurso; si falla, no tocar estado
-    auto* resource = Resource::Cache::get()->getMusic(name);
-    if (resource == nullptr) {
-        // manejo de error opcional
-        return;
+    if (!music_enabled_) return;
+
+    auto* resource = AudioResource::getMusic(name);
+    if (resource == nullptr) return;
+
+    if (crossfade_ms > 0 && music_.state == MusicState::PLAYING) {
+        JA_CrossfadeMusic(resource, crossfade_ms, loop);
+    } else {
+        if (music_.state == MusicState::PLAYING) {
+            JA_StopMusic();
+        }
+        JA_PlayMusic(resource, loop);
    }

-    // Si hay algo reproduciéndose, detenerlo primero (si el backend lo requiere)
-    if (music_.state == MusicState::PLAYING) {
-        JA_StopMusic();  // sustituir por la función de stop real del API si tiene otro nombre
-    }
-
-    // Llamada al motor para reproducir la nueva pista
-    JA_PlayMusic(resource, loop);
-
-    // Actualizar estado y metadatos después de iniciar con éxito
    music_.name = name;
    music_.loop = new_loop;
    music_.state = MusicState::PLAYING;
 }

+// Reproduce la música por puntero (con crossfade opcional)
+void Audio::playMusic(JA_Music_t* music, const int loop, const int crossfade_ms) {
+    if (!music_enabled_ || music == nullptr) return;
+
+    if (crossfade_ms > 0 && music_.state == MusicState::PLAYING) {
+        JA_CrossfadeMusic(music, crossfade_ms, loop);
+    } else {
+        if (music_.state == MusicState::PLAYING) {
+            JA_StopMusic();
+        }
+        JA_PlayMusic(music, loop);
+    }
+
+    music_.name.clear();  // nom desconegut quan es passa per punter
+    music_.loop = (loop != 0);
+    music_.state = MusicState::PLAYING;
+}
+
 // Pausa la música
-void Audio::pauseMusic() {  // NOLINT(readability-convert-member-functions-to-static)
+void Audio::pauseMusic() {
    if (music_enabled_ && music_.state == MusicState::PLAYING) {
        JA_PauseMusic();
        music_.state = MusicState::PAUSED;
@@ -79,7 +111,7 @@ void Audio::pauseMusic() {  // NOLINT(readability-convert-member-functions-to-st
 }

 // Continua la música pausada
-void Audio::resumeMusic() {  // NOLINT(readability-convert-member-functions-to-static)
+void Audio::resumeMusic() {
    if (music_enabled_ && music_.state == MusicState::PAUSED) {
        JA_ResumeMusic();
        music_.state = MusicState::PLAYING;
@@ -87,7 +119,7 @@ void Audio::resumeMusic() {  // NOLINT(readability-convert-member-functions-to-s
 }

 // Detiene la música
-void Audio::stopMusic() {  // NOLINT(readability-make-member-function-const)
+void Audio::stopMusic() {
    if (music_enabled_) {
        JA_StopMusic();
        music_.state = MusicState::STOPPED;
@@ -97,13 +129,13 @@ void Audio::stopMusic() {  // NOLINT(readability-make-member-function-const)
 // Reproduce un sonido por nombre
 void Audio::playSound(const std::string& name, Group group) const {
    if (sound_enabled_) {
-        JA_PlaySound(Resource::Cache::get()->getSound(name), 0, static_cast<int>(group));
+        JA_PlaySound(AudioResource::getSound(name), 0, static_cast<int>(group));
    }
 }

 // Reproduce un sonido por puntero directo
 void Audio::playSound(JA_Sound_t* sound, Group group) const {
-    if (sound_enabled_) {
+    if (sound_enabled_ && sound != nullptr) {
        JA_PlaySound(sound, 0, static_cast<int>(group));
    }
 }
@@ -138,7 +170,7 @@ auto Audio::getRealMusicState() -> MusicState {
    }
 }

-// Establece el volumen de los sonidos
+// Establece el volumen de los sonidos (float 0.0..1.0)
 void Audio::setSoundVolume(float sound_volume, Group group) const {
    if (sound_enabled_) {
        sound_volume = std::clamp(sound_volume, MIN_VOLUME, MAX_VOLUME);
@@ -147,7 +179,7 @@ void Audio::setSoundVolume(float sound_volume, Group group) const {
    }
 }

-// Establece el volumen de la música
+// Establece el volumen de la música (float 0.0..1.0)
 void Audio::setMusicVolume(float music_volume) const {
    if (music_enabled_) {
        music_volume = std::clamp(music_volume, MIN_VOLUME, MAX_VOLUME);
@@ -172,24 +204,9 @@ void Audio::enable(bool value) {
 // Inicializa SDL Audio
 void Audio::initSDLAudio() {
    if (!SDL_Init(SDL_INIT_AUDIO)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_AUDIO could not initialize! SDL Error: %s", SDL_GetError());
+        std::cout << "SDL_AUDIO could not initialize! SDL Error: " << SDL_GetError() << '\n';
    } else {
        JA_Init(FREQUENCY, SDL_AUDIO_S16LE, 2);
        enable(Options::audio.enabled);
-
-        // Aplicar estado de música y sonido guardado en las opciones.
-        // enable() ya aplica los volúmenes, pero no toca music_enabled_/sound_enabled_.
-        // Si alguno está desactivado, hay que forzar el volumen a 0 en el backend.
-        if (!Options::audio.music.enabled) {
-            setMusicVolume(0.0F);  // music_enabled_=true aún → llega a JA
-            enableMusic(false);
-        }
-        if (!Options::audio.sound.enabled) {
-            setSoundVolume(0.0F);  // sound_enabled_=true aún → llega a JA
-            enableSound(false);
-        }
-
-        std::cout << "\n** AUDIO SYSTEM **\n";
-        std::cout << "Audio system initialized successfully\n";
    }
 }
--- a/source/core/audio/audio.hpp
+++ b/source/core/audio/audio.hpp
@@ -1,28 +1,35 @@
 #pragma once

+#include <cstdint>  // Para int8_t, uint8_t
 #include <string>   // Para string
 #include <utility>  // Para move

 // --- Clase Audio: gestor de audio (singleton) ---
+// Implementació canònica, byte-idèntica entre projectes.
+// Els volums es manegen internament com a float 0.0–1.0; la capa de
+// presentació (menús, notificacions) usa les helpers toPercent/fromPercent
+// per mostrar 0–100 a l'usuari.
 class Audio {
   public:
    // --- Enums ---
-    enum class Group : int {
+    enum class Group : std::int8_t {
        ALL = -1,      // Todos los grupos
        GAME = 0,      // Sonidos del juego
        INTERFACE = 1  // Sonidos de la interfaz
    };

-    enum class MusicState {
+    enum class MusicState : std::uint8_t {
        PLAYING,  // Reproduciendo música
        PAUSED,   // Música pausada
        STOPPED,  // Música detenida
    };

    // --- Constantes ---
-    static constexpr float MAX_VOLUME = 1.0F;  // Volumen máximo
-    static constexpr float MIN_VOLUME = 0.0F;  // Volumen mínimo
-    static constexpr int FREQUENCY = 48000;    // Frecuencia de audio
+    static constexpr float MAX_VOLUME = 1.0F;          // Volumen máximo (float 0..1)
+    static constexpr float MIN_VOLUME = 0.0F;          // Volumen mínimo (float 0..1)
+    static constexpr float VOLUME_STEP = 0.05F;        // Pas estàndard per a UI (5%)
+    static constexpr int FREQUENCY = 48000;            // Frecuencia de audio
+    static constexpr int DEFAULT_CROSSFADE_MS = 1500;  // Duració del crossfade per defecte (ms)

    // --- Singleton ---
    static void init();                               // Inicializa el objeto Audio
@@ -34,21 +41,31 @@ class Audio {
    static void update();  // Actualización del sistema de audio

    // --- Control de música ---
-    void playMusic(const std::string& name, int loop = -1);  // Reproducir música en bucle
-    void pauseMusic();                                       // Pausar reproducción de música
-    void resumeMusic();                                      // Continua la música pausada
-    void stopMusic();                                        // Detener completamente la música
-    void fadeOutMusic(int milliseconds) const;               // Fundido de salida de la música
+    void playMusic(const std::string& name, int loop = -1, int crossfade_ms = 0);   // Reproducir música por nombre (con crossfade opcional)
+    void playMusic(struct JA_Music_t* music, int loop = -1, int crossfade_ms = 0);  // Reproducir música por puntero (con crossfade opcional)
+    void pauseMusic();                                                              // Pausar reproducción de música
+    void resumeMusic();                                                             // Continua la música pausada
+    void stopMusic();                                                               // Detener completamente la música
+    void fadeOutMusic(int milliseconds) const;                                      // Fundido de salida de la música

    // --- Control de sonidos ---
    void playSound(const std::string& name, Group group = Group::GAME) const;   // Reproducir sonido puntual por nombre
    void playSound(struct JA_Sound_t* sound, Group group = Group::GAME) const;  // Reproducir sonido puntual por puntero
    void stopAllSounds() const;                                                 // Detener todos los sonidos

-    // --- Control de volumen ---
+    // --- Control de volumen (API interna: float 0.0..1.0) ---
    void setSoundVolume(float volume, Group group = Group::ALL) const;  // Ajustar volumen de efectos
    void setMusicVolume(float volume) const;                            // Ajustar volumen de música

+    // --- Helpers de conversió per a la capa de presentació ---
+    // UI (menús, notificacions) manega enters 0..100; internament viu float 0..1.
+    static constexpr auto toPercent(float volume) -> int {
+        return static_cast<int>(volume * 100.0F + 0.5F);
+    }
+    static constexpr auto fromPercent(int percent) -> float {
+        return static_cast<float>(percent) / 100.0F;
+    }
+
    // --- Configuración general ---
    void enable(bool value);                        // Establecer estado general
    void toggleEnabled() { enabled_ = !enabled_; }  // Alternar estado general
--- a/source/core/audio/audio_adapter.cpp
+++ b/source/core/audio/audio_adapter.cpp
@@ -0,0 +1,13 @@
+#include "core/audio/audio_adapter.hpp"
+
+#include "core/resources/resource_cache.hpp"
+
+namespace AudioResource {
+    JA_Music_t* getMusic(const std::string& name) {
+        return Resource::Cache::get()->getMusic(name);
+    }
+
+    JA_Sound_t* getSound(const std::string& name) {
+        return Resource::Cache::get()->getSound(name);
+    }
+}  // namespace AudioResource
--- a/source/core/audio/audio_adapter.hpp
+++ b/source/core/audio/audio_adapter.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+// --- Audio Resource Adapter ---
+// Aquest fitxer exposa una interfície comuna a Audio per obtenir JA_Music_t* /
+// JA_Sound_t* per nom. Cada projecte la implementa en audio_adapter.cpp
+// delegant al seu singleton de recursos (Resource::get(), Resource::Cache::get(),
+// etc.). Això permet que audio.hpp/audio.cpp siguin idèntics entre projectes.
+
+#include <string>  // Para string
+
+struct JA_Music_t;
+struct JA_Sound_t;
+
+namespace AudioResource {
+    JA_Music_t* getMusic(const std::string& name);
+    JA_Sound_t* getSound(const std::string& name);
+}  // namespace AudioResource
--- a/source/core/audio/jail_audio.hpp
+++ b/source/core/audio/jail_audio.hpp
@@ -3,24 +3,41 @@
 // --- Includes ---
 #include <SDL3/SDL.h>
 #include <stdint.h>  // Para uint32_t, uint8_t
-#include <stdio.h>   // Para NULL, fseek, printf, fclose, fopen, fread, ftell, FILE, SEEK_END, SEEK_SET
+#include <stdio.h>   // Para NULL, fseek, fclose, fopen, fread, ftell, FILE, SEEK_END, SEEK_SET
 #include <stdlib.h>  // Para free, malloc
-#include <string.h>  // Para strcpy, strlen
+
+#include <iostream>  // Para std::cout
+#include <memory>    // Para std::unique_ptr
+#include <string>    // Para std::string
+#include <vector>    // Para std::vector

 #define STB_VORBIS_HEADER_ONLY
-#include "external/stb_vorbis.h"  // Para stb_vorbis_decode_memory
+#include "external/stb_vorbis.c"  // Para stb_vorbis_open_memory i streaming
+
+// Deleter stateless per a buffers reservats amb `SDL_malloc` / `SDL_LoadWAV*`.
+// Compatible amb `std::unique_ptr<Uint8[], SDLFreeDeleter>` — zero size
+// overhead gràcies a EBO, igual que un unique_ptr amb default_delete.
+struct SDLFreeDeleter {
+    void operator()(Uint8* p) const noexcept {
+        if (p) SDL_free(p);
+    }
+};

 // --- Public Enums ---
-enum JA_Channel_state { JA_CHANNEL_INVALID,
+enum JA_Channel_state {
+    JA_CHANNEL_INVALID,
    JA_CHANNEL_FREE,
    JA_CHANNEL_PLAYING,
    JA_CHANNEL_PAUSED,
-    JA_SOUND_DISABLED };
-enum JA_Music_state { JA_MUSIC_INVALID,
+    JA_SOUND_DISABLED,
+};
+enum JA_Music_state {
+    JA_MUSIC_INVALID,
    JA_MUSIC_PLAYING,
    JA_MUSIC_PAUSED,
    JA_MUSIC_STOPPED,
-    JA_MUSIC_DISABLED };
+    JA_MUSIC_DISABLED,
+};

 // --- Struct Definitions ---
 #define JA_MAX_SIMULTANEOUS_CHANNELS 20
@@ -29,7 +46,9 @@ enum JA_Music_state { JA_MUSIC_INVALID,
 struct JA_Sound_t {
    SDL_AudioSpec spec{SDL_AUDIO_S16, 2, 48000};
    Uint32 length{0};
-    Uint8* buffer{NULL};
+    // Buffer descomprimit (PCM) propietat del sound. Reservat per SDL_LoadWAV
+    // via SDL_malloc; el deleter `SDLFreeDeleter` allibera amb SDL_free.
+    std::unique_ptr<Uint8[], SDLFreeDeleter> buffer;
 };

 struct JA_Channel_t {
@@ -44,21 +63,22 @@ struct JA_Channel_t {
 struct JA_Music_t {
    SDL_AudioSpec spec{SDL_AUDIO_S16, 2, 48000};

-    // OGG comprimit en memòria. Propietat nostra; es copia des del fitxer una
-    // sola vegada en JA_LoadMusic i es descomprimix en chunks per streaming.
-    Uint8* ogg_data{nullptr};
-    Uint32 ogg_length{0};
-    stb_vorbis* vorbis{nullptr};  // Handle del decoder, viu tot el cicle del JA_Music_t
+    // OGG comprimit en memòria. Propietat nostra; es copia des del buffer
+    // d'entrada una sola vegada en JA_LoadMusic i es descomprimix en chunks
+    // per streaming. Com que stb_vorbis guarda un punter persistent al
+    // `.data()` d'aquest vector, no el podem resize'jar un cop establert
+    // (una reallocation invalidaria el punter que el decoder conserva).
+    std::vector<Uint8> ogg_data;
+    stb_vorbis* vorbis{nullptr};  // handle del decoder, viu tot el cicle del JA_Music_t

-    char* filename{nullptr};
+    std::string filename;

-    int times{0};  // Loops restants (-1 = infinit, 0 = un sol play)
+    int times{0};  // loops restants (-1 = infinit, 0 = un sol play)
    SDL_AudioStream* stream{nullptr};
    JA_Music_state state{JA_MUSIC_INVALID};
 };

-// --- Internal Global State ---
-// Marcado 'inline' (C++17) para asegurar una única instancia.
+// --- Internal Global State (inline, C++17) ---

 inline JA_Music_t* current_music{nullptr};
 inline JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS];
@@ -70,15 +90,27 @@ inline bool JA_musicEnabled{true};
 inline bool JA_soundEnabled{true};
 inline SDL_AudioDeviceID sdlAudioDevice{0};

-inline bool fading{false};
-inline int fade_start_time{0};
-inline int fade_duration{0};
-inline float fade_initial_volume{0.0f};  // Corregido de 'int' a 'float'
+// --- Crossfade / Fade State ---
+struct JA_FadeState {
+    bool active{false};
+    Uint64 start_time{0};
+    int duration_ms{0};
+    float initial_volume{0.0f};
+};
+
+struct JA_OutgoingMusic {
+    SDL_AudioStream* stream{nullptr};
+    JA_FadeState fade;
+};
+
+inline JA_OutgoingMusic outgoing_music;
+inline JA_FadeState incoming_fade;

 // --- Forward Declarations ---
 inline void JA_StopMusic();
 inline void JA_StopChannel(const int channel);
 inline int JA_PlaySoundOnChannel(JA_Sound_t* sound, const int channel, const int loop = 0, const int group = 0);
+inline void JA_CrossfadeMusic(JA_Music_t* music, int crossfade_ms, int loop = -1);

 // --- Music streaming internals ---
 // Bytes-per-sample per canal (sempre s16)
@@ -96,15 +128,15 @@ inline int JA_FeedMusicChunk(JA_Music_t* music) {
    if (!music || !music->vorbis || !music->stream) return 0;

    short chunk[JA_MUSIC_CHUNK_SHORTS];
-    const int channels = music->spec.channels;
+    const int num_channels = music->spec.channels;
    const int samples_per_channel = stb_vorbis_get_samples_short_interleaved(
        music->vorbis,
-        channels,
+        num_channels,
        chunk,
        JA_MUSIC_CHUNK_SHORTS);
    if (samples_per_channel <= 0) return 0;

-    const int bytes = samples_per_channel * channels * JA_MUSIC_BYTES_PER_SAMPLE;
+    const int bytes = samples_per_channel * num_channels * JA_MUSIC_BYTES_PER_SAMPLE;
    SDL_PutAudioStreamData(music->stream, chunk, bytes);
    return samples_per_channel;
 }
@@ -131,20 +163,51 @@ inline void JA_PumpMusic(JA_Music_t* music) {
    }
 }

+// Pre-carrega `duration_ms` de so dins l'stream actual abans que l'stream
+// siga robat per outgoing_music (crossfade o fade-out). Imprescindible amb
+// streaming: l'stream robat no es pot re-alimentar perquè perd la referència
+// al seu vorbis decoder. No aplica loop — si el vorbis s'esgota abans, parem.
+inline void JA_PreFillOutgoing(JA_Music_t* music, int duration_ms) {
+    if (!music || !music->vorbis || !music->stream) return;
+
+    const int bytes_per_second = music->spec.freq * music->spec.channels * JA_MUSIC_BYTES_PER_SAMPLE;
+    const int needed_bytes = static_cast<int>((static_cast<int64_t>(duration_ms) * bytes_per_second) / 1000);
+
+    while (SDL_GetAudioStreamAvailable(music->stream) < needed_bytes) {
+        const int decoded = JA_FeedMusicChunk(music);
+        if (decoded <= 0) break;  // EOF: deixem drenar el que hi haja
+    }
+}
+
 // --- Core Functions ---

 inline void JA_Update() {
+    // --- Outgoing music fade-out (crossfade o fade-out a silencio) ---
+    if (outgoing_music.stream && outgoing_music.fade.active) {
+        Uint64 now = SDL_GetTicks();
+        Uint64 elapsed = now - outgoing_music.fade.start_time;
+        if (elapsed >= (Uint64)outgoing_music.fade.duration_ms) {
+            SDL_DestroyAudioStream(outgoing_music.stream);
+            outgoing_music.stream = nullptr;
+            outgoing_music.fade.active = false;
+        } else {
+            float percent = (float)elapsed / (float)outgoing_music.fade.duration_ms;
+            SDL_SetAudioStreamGain(outgoing_music.stream, outgoing_music.fade.initial_volume * (1.0f - percent));
+        }
+    }
+
+    // --- Current music ---
    if (JA_musicEnabled && current_music && current_music->state == JA_MUSIC_PLAYING) {
-        if (fading) {
-            int time = SDL_GetTicks();
-            if (time > (fade_start_time + fade_duration)) {
-                fading = false;
-                JA_StopMusic();
-                return;
+        // Fade-in (parte de un crossfade)
+        if (incoming_fade.active) {
+            Uint64 now = SDL_GetTicks();
+            Uint64 elapsed = now - incoming_fade.start_time;
+            if (elapsed >= (Uint64)incoming_fade.duration_ms) {
+                incoming_fade.active = false;
+                SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
            } else {
-                const int time_passed = time - fade_start_time;
-                const float percent = (float)time_passed / (float)fade_duration;
-                SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume * (1.0 - percent));
+                float percent = (float)elapsed / (float)incoming_fade.duration_ms;
+                SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume * percent);
            }
        }

@@ -156,12 +219,13 @@ inline void JA_Update() {
        }
    }

+    // --- Sound channels ---
    if (JA_soundEnabled) {
        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; ++i)
            if (channels[i].state == JA_CHANNEL_PLAYING) {
                if (channels[i].times != 0) {
                    if ((Uint32)SDL_GetAudioStreamAvailable(channels[i].stream) < (channels[i].sound->length / 2)) {
-                        SDL_PutAudioStreamData(channels[i].stream, channels[i].sound->buffer, channels[i].sound->length);
+                        SDL_PutAudioStreamData(channels[i].stream, channels[i].sound->buffer.get(), channels[i].sound->length);
                        if (channels[i].times > 0) channels[i].times--;
                    }
                } else {
@@ -172,20 +236,20 @@ inline void JA_Update() {
 }

 inline void JA_Init(const int freq, const SDL_AudioFormat format, const int num_channels) {
-#ifdef _DEBUG
-    SDL_SetLogPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_DEBUG);
-#endif
-
    JA_audioSpec = {format, num_channels, freq};
-    if (sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);  // Corregido: !sdlAudioDevice -> sdlAudioDevice
+    if (sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);
    sdlAudioDevice = SDL_OpenAudioDevice(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &JA_audioSpec);
-    if (sdlAudioDevice == 0) SDL_Log("Failed to initialize SDL audio!");
+    if (sdlAudioDevice == 0) std::cout << "Failed to initialize SDL audio!" << '\n';
    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; ++i) channels[i].state = JA_CHANNEL_FREE;
    for (int i = 0; i < JA_MAX_GROUPS; ++i) JA_soundVolume[i] = 0.5f;
 }

 inline void JA_Quit() {
-    if (sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);  // Corregido: !sdlAudioDevice -> sdlAudioDevice
+    if (outgoing_music.stream) {
+        SDL_DestroyAudioStream(outgoing_music.stream);
+        outgoing_music.stream = nullptr;
+    }
+    if (sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);
    sdlAudioDevice = 0;
 }

@@ -194,26 +258,25 @@ inline void JA_Quit() {
 inline JA_Music_t* JA_LoadMusic(const Uint8* buffer, Uint32 length) {
    if (!buffer || length == 0) return nullptr;

-    // Còpia del OGG comprimit: stb_vorbis llig de forma persistent aquesta
-    // memòria mentre el handle estiga viu, així que hem de posseir-la nosaltres.
-    Uint8* ogg_copy = static_cast<Uint8*>(SDL_malloc(length));
-    if (!ogg_copy) return nullptr;
-    SDL_memcpy(ogg_copy, buffer, length);
+    // Allocem el JA_Music_t primer per aprofitar el seu `std::vector<Uint8>`
+    // com a propietari del OGG comprimit. stb_vorbis guarda un punter
+    // persistent al buffer; com que ací no el resize'jem, el .data() és
+    // estable durant tot el cicle de vida del music.
+    auto* music = new JA_Music_t();
+    music->ogg_data.assign(buffer, buffer + length);

    int error = 0;
-    stb_vorbis* vorbis = stb_vorbis_open_memory(ogg_copy, static_cast<int>(length), &error, nullptr);
-    if (!vorbis) {
-        SDL_free(ogg_copy);
-        SDL_Log("JA_LoadMusic: stb_vorbis_open_memory failed (error %d)", error);
+    music->vorbis = stb_vorbis_open_memory(music->ogg_data.data(),
+        static_cast<int>(length),
+        &error,
+        nullptr);
+    if (!music->vorbis) {
+        std::cout << "JA_LoadMusic: stb_vorbis_open_memory failed (error " << error << ")" << '\n';
+        delete music;
        return nullptr;
    }

-    auto* music = new JA_Music_t();
-    music->ogg_data = ogg_copy;
-    music->ogg_length = length;
-    music->vorbis = vorbis;
-
-    const stb_vorbis_info info = stb_vorbis_get_info(vorbis);
+    const stb_vorbis_info info = stb_vorbis_get_info(music->vorbis);
    music->spec.channels = info.channels;
    music->spec.freq = static_cast<int>(info.sample_rate);
    music->spec.format = SDL_AUDIO_S16;
@@ -222,31 +285,36 @@ inline JA_Music_t* JA_LoadMusic(const Uint8* buffer, Uint32 length) {
    return music;
 }

+// Overload amb filename — els callers l'usen per poder comparar la música
+// en curs amb JA_GetMusicFilename() i no rearrancar-la si ja és la mateixa.
+inline JA_Music_t* JA_LoadMusic(Uint8* buffer, Uint32 length, const char* filename) {
+    JA_Music_t* music = JA_LoadMusic(static_cast<const Uint8*>(buffer), length);
+    if (music && filename) music->filename = filename;
+    return music;
+}
+
 inline JA_Music_t* JA_LoadMusic(const char* filename) {
-    // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
+    // Carreguem primer el arxiu en memòria i després el descomprimim.
    FILE* f = fopen(filename, "rb");
-    if (!f) return NULL;  // Añadida comprobación de apertura
+    if (!f) return nullptr;
    fseek(f, 0, SEEK_END);
    long fsize = ftell(f);
    fseek(f, 0, SEEK_SET);
    auto* buffer = static_cast<Uint8*>(malloc(fsize + 1));
-    if (!buffer) {  // Añadida comprobación de malloc
+    if (!buffer) {
        fclose(f);
-        return NULL;
+        return nullptr;
    }
    if (fread(buffer, fsize, 1, f) != 1) {
        fclose(f);
        free(buffer);
-        return NULL;
+        return nullptr;
    }
    fclose(f);

-    JA_Music_t* music = JA_LoadMusic(buffer, fsize);
-    if (music) {  // Comprobar que JA_LoadMusic tuvo éxito
-        music->filename = static_cast<char*>(malloc(strlen(filename) + 1));
-        if (music->filename) {
-            strcpy(music->filename, filename);
-        }
+    JA_Music_t* music = JA_LoadMusic(static_cast<const Uint8*>(buffer), static_cast<Uint32>(fsize));
+    if (music) {
+        music->filename = filename;
    }

    free(buffer);
@@ -269,7 +337,7 @@ inline void JA_PlayMusic(JA_Music_t* music, const int loop = -1) {

    current_music->stream = SDL_CreateAudioStream(&current_music->spec, &JA_audioSpec);
    if (!current_music->stream) {
-        SDL_Log("Failed to create audio stream!");
+        std::cout << "Failed to create audio stream!" << '\n';
        current_music->state = JA_MUSIC_STOPPED;
        return;
    }
@@ -278,18 +346,20 @@ inline void JA_PlayMusic(JA_Music_t* music, const int loop = -1) {
    // Pre-cargem el buffer abans de bindejar per evitar un underrun inicial.
    JA_PumpMusic(current_music);

-    if (!SDL_BindAudioStream(sdlAudioDevice, current_music->stream)) printf("[ERROR] SDL_BindAudioStream failed!\n");
+    if (!SDL_BindAudioStream(sdlAudioDevice, current_music->stream)) {
+        std::cout << "[ERROR] SDL_BindAudioStream failed!" << '\n';
+    }
 }

-inline char* JA_GetMusicFilename(const JA_Music_t* music = nullptr) {
+inline const char* JA_GetMusicFilename(const JA_Music_t* music = nullptr) {
    if (!music) music = current_music;
-    if (!music) return nullptr;  // Añadida comprobación
-    return music->filename;
+    if (!music || music->filename.empty()) return nullptr;
+    return music->filename.c_str();
 }

 inline void JA_PauseMusic() {
    if (!JA_musicEnabled) return;
-    if (!current_music || current_music->state != JA_MUSIC_PLAYING) return;  // Comprobación mejorada
+    if (!current_music || current_music->state != JA_MUSIC_PLAYING) return;

    current_music->state = JA_MUSIC_PAUSED;
    SDL_UnbindAudioStream(current_music->stream);
@@ -297,13 +367,21 @@ inline void JA_PauseMusic() {

 inline void JA_ResumeMusic() {
    if (!JA_musicEnabled) return;
-    if (!current_music || current_music->state != JA_MUSIC_PAUSED) return;  // Comprobación mejorada
+    if (!current_music || current_music->state != JA_MUSIC_PAUSED) return;

    current_music->state = JA_MUSIC_PLAYING;
    SDL_BindAudioStream(sdlAudioDevice, current_music->stream);
 }

 inline void JA_StopMusic() {
+    // Limpiar outgoing crossfade si existe
+    if (outgoing_music.stream) {
+        SDL_DestroyAudioStream(outgoing_music.stream);
+        outgoing_music.stream = nullptr;
+        outgoing_music.fade.active = false;
+    }
+    incoming_fade.active = false;
+
    if (!current_music || current_music->state == JA_MUSIC_INVALID || current_music->state == JA_MUSIC_STOPPED) return;

    current_music->state = JA_MUSIC_STOPPED;
@@ -316,17 +394,73 @@ inline void JA_StopMusic() {
    if (current_music->vorbis) {
        stb_vorbis_seek_start(current_music->vorbis);
    }
-    // No liberem filename aquí; es fa en JA_DeleteMusic.
 }

 inline void JA_FadeOutMusic(const int milliseconds) {
    if (!JA_musicEnabled) return;
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    if (!current_music || current_music->state != JA_MUSIC_PLAYING) return;

-    fading = true;
-    fade_start_time = SDL_GetTicks();
-    fade_duration = milliseconds;
-    fade_initial_volume = JA_musicVolume;
+    // Destruir outgoing anterior si existe
+    if (outgoing_music.stream) {
+        SDL_DestroyAudioStream(outgoing_music.stream);
+        outgoing_music.stream = nullptr;
+    }
+
+    // Pre-omplim l'stream amb `milliseconds` de so: un cop robat, ja no
+    // tindrà accés al vorbis decoder i només podrà drenar el que tinga.
+    JA_PreFillOutgoing(current_music, milliseconds);
+
+    // Robar el stream del current_music al outgoing
+    outgoing_music.stream = current_music->stream;
+    outgoing_music.fade = {true, SDL_GetTicks(), milliseconds, JA_musicVolume};
+
+    // Dejar current_music sin stream (ya lo tiene outgoing)
+    current_music->stream = nullptr;
+    current_music->state = JA_MUSIC_STOPPED;
+    if (current_music->vorbis) stb_vorbis_seek_start(current_music->vorbis);
+    incoming_fade.active = false;
+}
+
+inline void JA_CrossfadeMusic(JA_Music_t* music, const int crossfade_ms, const int loop) {
+    if (!JA_musicEnabled || !music || !music->vorbis) return;
+
+    // Destruir outgoing anterior si existe (crossfade durante crossfade)
+    if (outgoing_music.stream) {
+        SDL_DestroyAudioStream(outgoing_music.stream);
+        outgoing_music.stream = nullptr;
+        outgoing_music.fade.active = false;
+    }
+
+    // Robar el stream de la musica actual al outgoing para el fade-out.
+    // Pre-omplim amb `crossfade_ms` de so perquè no es quede en silenci
+    // abans d'acabar el fade (l'stream robat ja no pot alimentar-se).
+    if (current_music && current_music->state == JA_MUSIC_PLAYING && current_music->stream) {
+        JA_PreFillOutgoing(current_music, crossfade_ms);
+        outgoing_music.stream = current_music->stream;
+        outgoing_music.fade = {true, SDL_GetTicks(), crossfade_ms, JA_musicVolume};
+        current_music->stream = nullptr;
+        current_music->state = JA_MUSIC_STOPPED;
+        if (current_music->vorbis) stb_vorbis_seek_start(current_music->vorbis);
+    }
+
+    // Iniciar la nueva pista con gain=0 (el fade-in la sube gradualmente)
+    current_music = music;
+    current_music->state = JA_MUSIC_PLAYING;
+    current_music->times = loop;
+
+    stb_vorbis_seek_start(current_music->vorbis);
+    current_music->stream = SDL_CreateAudioStream(&current_music->spec, &JA_audioSpec);
+    if (!current_music->stream) {
+        std::cout << "Failed to create audio stream for crossfade!" << '\n';
+        current_music->state = JA_MUSIC_STOPPED;
+        return;
+    }
+    SDL_SetAudioStreamGain(current_music->stream, 0.0f);
+    JA_PumpMusic(current_music);  // pre-carrega abans de bindejar
+    SDL_BindAudioStream(sdlAudioDevice, current_music->stream);
+
+    // Configurar fade-in
+    incoming_fade = {true, SDL_GetTicks(), crossfade_ms, 0.0f};
 }

 inline JA_Music_state JA_GetMusicState() {
@@ -344,8 +478,8 @@ inline void JA_DeleteMusic(JA_Music_t* music) {
    }
    if (music->stream) SDL_DestroyAudioStream(music->stream);
    if (music->vorbis) stb_vorbis_close(music->vorbis);
-    SDL_free(music->ogg_data);
-    free(music->filename);  // filename es libera aquí
+    // ogg_data (std::vector) i filename (std::string) s'alliberen sols
+    // al destructor de JA_Music_t.
    delete music;
 }

@@ -358,49 +492,40 @@ inline float JA_SetMusicVolume(float volume) {
 }

 inline void JA_SetMusicPosition(float /*value*/) {
-    // No implementat amb el backend de streaming. Mai va arribar a usar-se
-    // en el codi existent, així que es manté com a stub.
+    // No implementat amb el backend de streaming.
 }

 inline float JA_GetMusicPosition() {
-    // Veure nota a JA_SetMusicPosition.
    return 0.0f;
 }

 inline void JA_EnableMusic(const bool value) {
    if (!value && current_music && (current_music->state == JA_MUSIC_PLAYING)) JA_StopMusic();
-
    JA_musicEnabled = value;
 }

 // --- Sound Functions ---

-inline JA_Sound_t* JA_NewSound(Uint8* buffer, Uint32 length) {
-    JA_Sound_t* sound = new JA_Sound_t();
-    sound->buffer = buffer;
-    sound->length = length;
-    // Nota: spec se queda con los valores por defecto.
-    return sound;
-}
-
 inline JA_Sound_t* JA_LoadSound(uint8_t* buffer, uint32_t size) {
-    JA_Sound_t* sound = new JA_Sound_t();
-    if (!SDL_LoadWAV_IO(SDL_IOFromMem(buffer, size), 1, &sound->spec, &sound->buffer, &sound->length)) {
-        SDL_Log("Failed to load WAV from memory: %s", SDL_GetError());
-        delete sound;
+    auto sound = std::make_unique<JA_Sound_t>();
+    Uint8* raw = nullptr;
+    if (!SDL_LoadWAV_IO(SDL_IOFromMem(buffer, size), 1, &sound->spec, &raw, &sound->length)) {
+        std::cout << "Failed to load WAV from memory: " << SDL_GetError() << '\n';
        return nullptr;
    }
-    return sound;
+    sound->buffer.reset(raw);  // adopta el SDL_malloc'd buffer
+    return sound.release();
 }

 inline JA_Sound_t* JA_LoadSound(const char* filename) {
-    JA_Sound_t* sound = new JA_Sound_t();
-    if (!SDL_LoadWAV(filename, &sound->spec, &sound->buffer, &sound->length)) {
-        SDL_Log("Failed to load WAV file: %s", SDL_GetError());
-        delete sound;
+    auto sound = std::make_unique<JA_Sound_t>();
+    Uint8* raw = nullptr;
+    if (!SDL_LoadWAV(filename, &sound->spec, &raw, &sound->length)) {
+        std::cout << "Failed to load WAV file: " << SDL_GetError() << '\n';
        return nullptr;
    }
-    return sound;
+    sound->buffer.reset(raw);  // adopta el SDL_malloc'd buffer
+    return sound.release();
 }

 inline int JA_PlaySound(JA_Sound_t* sound, const int loop = 0, const int group = 0) {
@@ -420,22 +545,22 @@ inline int JA_PlaySoundOnChannel(JA_Sound_t* sound, const int channel, const int
    if (!JA_soundEnabled || !sound) return -1;
    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return -1;

-    JA_StopChannel(channel);  // Detiene y limpia el canal si estaba en uso
+    JA_StopChannel(channel);

    channels[channel].sound = sound;
    channels[channel].times = loop;
    channels[channel].pos = 0;
-    channels[channel].group = group;  // Asignar grupo
+    channels[channel].group = group;
    channels[channel].state = JA_CHANNEL_PLAYING;
    channels[channel].stream = SDL_CreateAudioStream(&channels[channel].sound->spec, &JA_audioSpec);

    if (!channels[channel].stream) {
-        SDL_Log("Failed to create audio stream for sound!");
+        std::cout << "Failed to create audio stream for sound!" << '\n';
        channels[channel].state = JA_CHANNEL_FREE;
        return -1;
    }

-    SDL_PutAudioStreamData(channels[channel].stream, channels[channel].sound->buffer, channels[channel].sound->length);
+    SDL_PutAudioStreamData(channels[channel].stream, channels[channel].sound->buffer.get(), channels[channel].sound->length);
    SDL_SetAudioStreamGain(channels[channel].stream, JA_soundVolume[group]);
    SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);

@@ -447,7 +572,7 @@ inline void JA_DeleteSound(JA_Sound_t* sound) {
    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
        if (channels[i].sound == sound) JA_StopChannel(i);
    }
-    SDL_free(sound->buffer);
+    // buffer es destrueix automàticament via RAII (SDLFreeDeleter).
    delete sound;
 }

@@ -493,7 +618,7 @@ inline void JA_StopChannel(const int channel) {
                channels[i].stream = nullptr;
                channels[i].state = JA_CHANNEL_FREE;
                channels[i].pos = 0;
-                channels[i].sound = NULL;
+                channels[i].sound = nullptr;
            }
        }
    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
@@ -502,7 +627,7 @@ inline void JA_StopChannel(const int channel) {
            channels[channel].stream = nullptr;
            channels[channel].state = JA_CHANNEL_FREE;
            channels[channel].pos = 0;
-            channels[channel].sound = NULL;
+            channels[channel].sound = nullptr;
        }
    }
 }
@@ -514,8 +639,7 @@ inline JA_Channel_state JA_GetChannelState(const int channel) {
    return channels[channel].state;
 }

-inline float JA_SetSoundVolume(float volume, const int group = -1)  // -1 para todos los grupos
-{
+inline float JA_SetSoundVolume(float volume, const int group = -1) {
    const float v = SDL_clamp(volume, 0.0f, 1.0f);

    if (group == -1) {
@@ -525,10 +649,10 @@ inline float JA_SetSoundVolume(float volume, const int group = -1)  // -1 para t
    } else if (group >= 0 && group < JA_MAX_GROUPS) {
        JA_soundVolume[group] = v;
    } else {
-        return v;  // Grupo inválido
+        return v;
    }

-    // Aplicar volumen a canales activos
+    // Aplicar volum als canals actius.
    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
        if ((channels[i].state == JA_CHANNEL_PLAYING) || (channels[i].state == JA_CHANNEL_PAUSED)) {
            if (group == -1 || channels[i].group == group) {
@@ -543,13 +667,13 @@ inline float JA_SetSoundVolume(float volume, const int group = -1)  // -1 para t

 inline void JA_EnableSound(const bool value) {
    if (!value) {
-        JA_StopChannel(-1);  // Detener todos los canales
+        JA_StopChannel(-1);
    }
    JA_soundEnabled = value;
 }

 inline float JA_SetVolume(float volume) {
    float v = JA_SetMusicVolume(volume);
-    JA_SetSoundVolume(v, -1);  // Aplicar a todos los grupos de sonido
+    JA_SetSoundVolume(v, -1);
    return v;
 }
--- a/source/core/input/input.cpp
+++ b/source/core/input/input.cpp
@@ -10,6 +10,41 @@

 #include "game/options.hpp"  // Para Options::controls

+// Emscripten-only: SDL 3.4+ ja no casa el GUID dels mandos de Chrome Android
+// amb gamecontrollerdb (el gamepad.id d'Android no porta Vendor/Product, el
+// parser extreu valors escombraries, el GUID resultant no està a la db i el
+// gamepad queda obert amb un mapping incorrecte). Com el W3C Gamepad API
+// garanteix el layout estàndard quan el navegador reporta mapping=="standard",
+// injectem un mapping SDL amb eixe layout per al GUID del joystick abans
+// d'obrir-lo com gamepad. Fora d'Emscripten és un no-op.
+static void installWebStandardMapping(SDL_JoystickID jid) {
+#ifdef __EMSCRIPTEN__
+    SDL_GUID guid = SDL_GetJoystickGUIDForID(jid);
+    char guidStr[33];
+    SDL_GUIDToString(guid, guidStr, sizeof(guidStr));
+    const char* name = SDL_GetJoystickNameForID(jid);
+    if (!name || !*name) name = "Standard Gamepad";
+
+    char mapping[512];
+    SDL_snprintf(mapping, sizeof(mapping),
+        "%s,%s,"
+        "a:b0,b:b1,x:b2,y:b3,"
+        "leftshoulder:b4,rightshoulder:b5,"
+        "lefttrigger:b6,righttrigger:b7,"
+        "back:b8,start:b9,"
+        "leftstick:b10,rightstick:b11,"
+        "dpup:b12,dpdown:b13,dpleft:b14,dpright:b15,"
+        "guide:b16,"
+        "leftx:a0,lefty:a1,rightx:a2,righty:a3,"
+        "platform:Emscripten",
+        guidStr,
+        name);
+    SDL_AddGamepadMapping(mapping);
+#else
+    (void)jid;
+#endif
+}
+
 // Singleton
 Input* Input::instance = nullptr;

@@ -420,6 +455,7 @@ auto Input::handleEvent(const SDL_Event& event) -> std::string {  // NOLINT(read
 }

 auto Input::addGamepad(int device_index) -> std::string {  // NOLINT(readability-convert-member-functions-to-static)
+    installWebStandardMapping(device_index);
    SDL_Gamepad* pad = SDL_OpenGamepad(device_index);
    if (pad == nullptr) {
        std::cerr << "Error al abrir el gamepad: " << SDL_GetError() << '\n';
--- a/source/core/input/input.hpp
+++ b/source/core/input/input.hpp
@@ -51,10 +51,20 @@ class Input {
        std::string path;                                  // Ruta del dispositivo
        std::unordered_map<Action, ButtonState> bindings;  // Mapa de acciones a estados de botón

+        // Recorta el nombre del mando hasta el primer '(' o '[' y elimina espacios finales.
+        // Evita nombres como "Retroid Controller (vendor: 1001) ..." en las notificaciones.
+        static auto trimName(const char* raw) -> std::string {
+            std::string s(raw != nullptr ? raw : "");
+            const auto pos = s.find_first_of("([");
+            if (pos != std::string::npos) { s.erase(pos); }
+            while (!s.empty() && s.back() == ' ') { s.pop_back(); }
+            return s;
+        }
+
        explicit Gamepad(SDL_Gamepad* gamepad)
            : pad(gamepad),
              instance_id(SDL_GetJoystickID(SDL_GetGamepadJoystick(gamepad))),
-              name(std::string(SDL_GetGamepadName(gamepad))),
+              name(trimName(SDL_GetGamepadName(gamepad))),
              path(std::string(SDL_GetGamepadPath(pad))),
              bindings{
                  // Movimiento del jugador
--- a/source/core/rendering/screen.cpp
+++ b/source/core/rendering/screen.cpp
@@ -48,8 +48,10 @@ Screen* Screen::screen = nullptr;
 //     i el joc es veu minúscul fins que l'usuari força un refresh manual
 //     (p. ex., canviant el mode d'escalat amb F7).
 //
-// Solució: registrem callbacks natius d'Emscripten (fullscreenchange, resize,
+// Solució: registrem callbacks natius d'Emscripten (fullscreenchange,
 // orientationchange) que re-sincronitzen SDL amb l'estat real del navegador.
+// NO registrem resize callback: en mòbil el scroll fa que el navegador oculti/
+// mostri la barra d'URL, disparant un resize del DOM per cada scroll.
 // Tots delegen en Screen::handleCanvasResized(), que crida setVideoMode()
 // amb l'estat de fullscreen actualitzat — això és el que realment restaura
 // la finestra SDL perquè dins setVideoMode es crida SDL_SetWindowFullscreen,
@@ -80,11 +82,6 @@ namespace {
        return EM_FALSE;
    }

-    auto onEmResize(int /*event_type*/, const EmscriptenUiEvent* /*event*/, void* /*user_data*/) -> EM_BOOL {
-        emscripten_async_call(deferredCanvasResize, nullptr, 0);
-        return EM_FALSE;
-    }
-
    auto onEmOrientationChange(int /*event_type*/, const EmscriptenOrientationChangeEvent* /*event*/, void* /*user_data*/) -> EM_BOOL {
        emscripten_async_call(deferredCanvasResize, nullptr, 0);
        return EM_FALSE;
@@ -832,8 +829,10 @@ auto Screen::initSDLVideo() -> bool {
 // Vegeu el bloc de documentació a dalt del fitxer per al context complet.
 void Screen::registerEmscriptenEventCallbacks() {  // NOLINT(readability-convert-member-functions-to-static)
 #ifdef __EMSCRIPTEN__
+    // NO registrem resize callback. En mòbil, fer scroll fa que el navegador
+    // oculti/mostri la barra d'URL disparant un resize del DOM per cada scroll,
+    // i això portaria a cridar setVideoMode innecessàriament. Alineat amb CC i CCAE.
    emscripten_set_fullscreenchange_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, nullptr, EM_TRUE, onEmFullscreenChange);
-    emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, nullptr, EM_TRUE, onEmResize);
    emscripten_set_orientationchange_callback(nullptr, EM_TRUE, onEmOrientationChange);
 #endif
 }
--- a/source/core/rendering/sdl3gpu/sdl3gpu_shader.cpp
+++ b/source/core/rendering/sdl3gpu/sdl3gpu_shader.cpp
@@ -8,11 +8,11 @@
 #include <iostream>   // std::cout

 #ifndef __APPLE__
-#include "core/rendering/sdl3gpu/crtpi_frag_spv.h"
-#include "core/rendering/sdl3gpu/downscale_frag_spv.h"
-#include "core/rendering/sdl3gpu/postfx_frag_spv.h"
-#include "core/rendering/sdl3gpu/postfx_vert_spv.h"
-#include "core/rendering/sdl3gpu/upscale_frag_spv.h"
+#include "core/rendering/sdl3gpu/spv/crtpi_frag_spv.h"
+#include "core/rendering/sdl3gpu/spv/downscale_frag_spv.h"
+#include "core/rendering/sdl3gpu/spv/postfx_frag_spv.h"
+#include "core/rendering/sdl3gpu/spv/postfx_vert_spv.h"
+#include "core/rendering/sdl3gpu/spv/upscale_frag_spv.h"
 #endif

 #ifdef __APPLE__
--- a/source/core/rendering/sdl3gpu/spv/.clang-format
+++ b/source/core/rendering/sdl3gpu/spv/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: Never
--- a/source/core/rendering/sdl3gpu/spv/.clang-tidy
+++ b/source/core/rendering/sdl3gpu/spv/.clang-tidy
@@ -0,0 +1,4 @@
+# source/core/rendering/sdl3gpu/spv/.clang-tidy
+Checks: '-*'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
--- a/source/core/rendering/sdl3gpu/spv/crtpi_frag_spv.h
+++ b/source/core/rendering/sdl3gpu/spv/crtpi_frag_spv.h
--- a/source/core/rendering/sdl3gpu/spv/downscale_frag_spv.h
+++ b/source/core/rendering/sdl3gpu/spv/downscale_frag_spv.h
--- a/source/core/rendering/sdl3gpu/spv/postfx_frag_spv.h
+++ b/source/core/rendering/sdl3gpu/spv/postfx_frag_spv.h
--- a/source/core/rendering/sdl3gpu/spv/postfx_vert_spv.h
+++ b/source/core/rendering/sdl3gpu/spv/postfx_vert_spv.h
--- a/source/core/rendering/sdl3gpu/spv/upscale_frag_spv.h
+++ b/source/core/rendering/sdl3gpu/spv/upscale_frag_spv.h
--- a/source/core/rendering/sprite/animated_sprite.cpp
+++ b/source/core/rendering/sprite/animated_sprite.cpp
@@ -219,7 +219,7 @@ AnimatedSprite::AnimatedSprite(std::shared_ptr<Surface> surface, SDL_FRect pos)
    : MovingSprite(std::move(surface), pos) {
    // animations_ queda buit (protegit per el guard de animate())
    if (surface_) {
-        clip_ = {.x = 0, .y = 0, .w = surface_->getWidth(), .h = surface_->getHeight()};
+        clip_ = {.x = 0, .y = 0, .w = static_cast<float>(surface_->getWidth()), .h = static_cast<float>(surface_->getHeight())};
    }
 }

--- a/source/core/rendering/sprite/dissolve_sprite.cpp
+++ b/source/core/rendering/sprite/dissolve_sprite.cpp
@@ -35,8 +35,8 @@ auto DissolveSprite::computePixelRank(int col, int row, int frame_h, DissolveDir
 DissolveSprite::DissolveSprite(std::shared_ptr<Surface> surface, SDL_FRect pos)
    : AnimatedSprite(std::move(surface), pos) {
    if (surface_) {
-        const int W = static_cast<int>(surface_->getWidth());
-        const int H = static_cast<int>(surface_->getHeight());
+        const int W = surface_->getWidth();
+        const int H = surface_->getHeight();
        surface_display_ = std::make_shared<Surface>(W, H);
        surface_display_->setTransparentColor(surface_->getTransparentColor());
        surface_display_->clear(surface_->getTransparentColor());
@@ -47,8 +47,8 @@ DissolveSprite::DissolveSprite(std::shared_ptr<Surface> surface, SDL_FRect pos)
 DissolveSprite::DissolveSprite(const AnimationResource& data)
    : AnimatedSprite(data) {
    if (surface_) {
-        const int W = static_cast<int>(surface_->getWidth());
-        const int H = static_cast<int>(surface_->getHeight());
+        const int W = surface_->getWidth();
+        const int H = surface_->getHeight();
        surface_display_ = std::make_shared<Surface>(W, H);
        surface_display_->setTransparentColor(surface_->getTransparentColor());
        // Inicialitza tots els píxels com a transparents
@@ -75,8 +75,8 @@ void DissolveSprite::rebuildDisplaySurface() {
    auto src_data = surface_->getSurfaceData();
    auto dst_data = surface_display_->getSurfaceData();

-    const int SRC_W = static_cast<int>(src_data->width);
-    const int DST_W = static_cast<int>(dst_data->width);
+    const int SRC_W = src_data->width;
+    const int DST_W = dst_data->width;
    const Uint8 TRANSPARENT = surface_->getTransparentColor();

    // Esborra frame anterior si ha canviat
--- a/source/core/rendering/sprite/sprite.cpp
+++ b/source/core/rendering/sprite/sprite.cpp
@@ -19,7 +19,7 @@ Sprite::Sprite() = default;

 Sprite::Sprite(std::shared_ptr<Surface> surface)
    : surface_(std::move(surface)),
-      pos_{0.0F, 0.0F, surface_->getWidth(), surface_->getHeight()},
+      pos_{0.0F, 0.0F, static_cast<float>(surface_->getWidth()), static_cast<float>(surface_->getHeight())},
      clip_(pos_) {}

 // Muestra el sprite por pantalla
--- a/source/core/rendering/surface.cpp
+++ b/source/core/rendering/surface.cpp
@@ -104,7 +104,7 @@ Surface::Surface(const std::string& file_path)
 }

 // Carga una superficie desde un archivo
-auto Surface::loadSurface(const std::string& file_path) -> SurfaceData {  // NOLINT(readability-convert-member-functions-to-static)
+auto Surface::loadSurface(const std::string& file_path) -> SurfaceData {
    // Load file using ResourceHelper (supports both filesystem and pack)
    std::vector<Uint8> buffer = Resource::Helper::loadFile(file_path);
    if (buffer.empty()) {
@@ -129,7 +129,7 @@ auto Surface::loadSurface(const std::string& file_path) -> SurfaceData {  // NOL

    // Crear y devolver directamente el objeto SurfaceData
    printWithDots("Surface : ", file_path.substr(file_path.find_last_of("\\/") + 1), "[ LOADED ]");
-    return {static_cast<float>(w), static_cast<float>(h), pixels};
+    return {static_cast<int>(w), static_cast<int>(h), pixels};
 }

 // Carga una paleta desde un archivo
@@ -149,7 +149,7 @@ void Surface::setColor(int index, Uint32 color) {

 // Rellena la superficie con un color
 void Surface::clear(Uint8 color) {  // NOLINT(readability-convert-member-functions-to-static)
-    const size_t TOTAL_PIXELS = surface_data_->width * surface_data_->height;
+    const size_t TOTAL_PIXELS = static_cast<size_t>(surface_data_->width) * static_cast<size_t>(surface_data_->height);
    Uint8* data_ptr = surface_data_->data.get();
    std::fill(data_ptr, data_ptr + TOTAL_PIXELS, color);
 }
@@ -165,19 +165,19 @@ void Surface::putPixel(int x, int y, Uint8 color) {  // NOLINT(readability-conve
 }

 // Obtiene el color de un pixel de la surface_data
-auto Surface::getPixel(int x, int y) -> Uint8 { return surface_data_->data.get()[x + (y * static_cast<int>(surface_data_->width))]; }
+auto Surface::getPixel(int x, int y) -> Uint8 { return surface_data_->data.get()[x + (y * surface_data_->width)]; }

 // Dibuja un rectangulo relleno
 void Surface::fillRect(const SDL_FRect* rect, Uint8 color) {  // NOLINT(readability-convert-member-functions-to-static)
    // Limitar los valores del rectángulo al tamaño de la superficie
    float x_start = std::max(0.0F, rect->x);
    float y_start = std::max(0.0F, rect->y);
-    float x_end = std::min(rect->x + rect->w, surface_data_->width);
-    float y_end = std::min(rect->y + rect->h, surface_data_->height);
+    float x_end = std::min(rect->x + rect->w, static_cast<float>(surface_data_->width));
+    float y_end = std::min(rect->y + rect->h, static_cast<float>(surface_data_->height));

    // Rellenar fila a fila con memset (memoria contigua por fila)
    Uint8* data_ptr = surface_data_->data.get();
-    const int SURF_WIDTH = static_cast<int>(surface_data_->width);
+    const int SURF_WIDTH = surface_data_->width;
    const int ROW_WIDTH = static_cast<int>(x_end) - static_cast<int>(x_start);
    for (int y = static_cast<int>(y_start); y < static_cast<int>(y_end); ++y) {
        std::memset(data_ptr + (y * SURF_WIDTH) + static_cast<int>(x_start), color, ROW_WIDTH);
@@ -189,12 +189,12 @@ void Surface::drawRectBorder(const SDL_FRect* rect, Uint8 color) {  // NOLINT(re
    // Limitar los valores del rectángulo al tamaño de la superficie
    float x_start = std::max(0.0F, rect->x);
    float y_start = std::max(0.0F, rect->y);
-    float x_end = std::min(rect->x + rect->w, surface_data_->width);
-    float y_end = std::min(rect->y + rect->h, surface_data_->height);
+    float x_end = std::min(rect->x + rect->w, static_cast<float>(surface_data_->width));
+    float y_end = std::min(rect->y + rect->h, static_cast<float>(surface_data_->height));

    // Dibujar bordes horizontales con memset (líneas contiguas en memoria)
    Uint8* data_ptr = surface_data_->data.get();
-    const int SURF_WIDTH = static_cast<int>(surface_data_->width);
+    const int SURF_WIDTH = surface_data_->width;
    const int ROW_WIDTH = static_cast<int>(x_end) - static_cast<int>(x_start);
    std::memset(data_ptr + (static_cast<int>(y_start) * SURF_WIDTH) + static_cast<int>(x_start), color, ROW_WIDTH);
    std::memset(data_ptr + ((static_cast<int>(y_end) - 1) * SURF_WIDTH) + static_cast<int>(x_start), color, ROW_WIDTH);
@@ -211,68 +211,38 @@ void Surface::drawRectBorder(const SDL_FRect* rect, Uint8 color) {  // NOLINT(re
    }
 }

-// Dibuja una linea
+// Dibuja una linea (Bresenham en enteros)
 void Surface::drawLine(float x1, float y1, float x2, float y2, Uint8 color) {  // NOLINT(readability-convert-member-functions-to-static)
-    // Calcula las diferencias
-    float dx = std::abs(x2 - x1);
-    float dy = std::abs(y2 - y1);
+    int ix1 = static_cast<int>(std::lround(x1));
+    int iy1 = static_cast<int>(std::lround(y1));
+    const int IX2 = static_cast<int>(std::lround(x2));
+    const int IY2 = static_cast<int>(std::lround(y2));

-    // Determina la dirección del incremento
-    float sx = (x1 < x2) ? 1 : -1;
-    float sy = (y1 < y2) ? 1 : -1;
+    const int DX = std::abs(IX2 - ix1);
+    const int DY = std::abs(IY2 - iy1);
+    const int SX = (ix1 < IX2) ? 1 : -1;
+    const int SY = (iy1 < IY2) ? 1 : -1;

-    float err = dx - dy;
+    const int SURF_W = surface_data_->width;
+    const int SURF_H = surface_data_->height;
+    Uint8* data_ptr = surface_data_->data.get();

+    int err = DX - DY;
    while (true) {
-        // Asegúrate de no dibujar fuera de los límites de la superficie
-        if (x1 >= 0 && x1 < surface_data_->width && y1 >= 0 && y1 < surface_data_->height) {
-            surface_data_->data.get()[static_cast<size_t>(x1 + (y1 * surface_data_->width))] = color;
+        if (ix1 >= 0 && ix1 < SURF_W && iy1 >= 0 && iy1 < SURF_H) {
+            data_ptr[ix1 + (iy1 * SURF_W)] = color;
        }
-
-        // Si alcanzamos el punto final, salimos
-        if (x1 == x2 && y1 == y2) {
+        if (ix1 == IX2 && iy1 == IY2) {
            break;
        }
-
        int e2 = 2 * err;
-        if (e2 > -dy) {
-            err -= dy;
-            x1 += sx;
+        if (e2 > -DY) {
+            err -= DY;
+            ix1 += SX;
        }
-        if (e2 < dx) {
-            err += dx;
-            y1 += sy;
-        }
-    }
-}
-
-void Surface::render(float dx, float dy, float sx, float sy, float w, float h) {  // NOLINT(readability-make-member-function-const)
-    auto surface_data = Screen::get()->getRendererSurface()->getSurfaceData();
-
-    // Limitar la región para evitar accesos fuera de rango en origen
-    w = std::min(w, surface_data_->width - sx);
-    h = std::min(h, surface_data_->height - sy);
-
-    // Limitar la región para evitar accesos fuera de rango en destino
-    w = std::min(w, surface_data->width - dx);
-    h = std::min(h, surface_data->height - dy);
-
-    const Uint8* src_ptr = surface_data_->data.get();
-    Uint8* dst_ptr = surface_data->data.get();
-    for (int iy = 0; iy < h; ++iy) {
-        for (int ix = 0; ix < w; ++ix) {
-            // Verificar que las coordenadas de destino están dentro de los límites
-            if (int dest_x = dx + ix; dest_x >= 0 && dest_x < surface_data->width) {
-                if (int dest_y = dy + iy; dest_y >= 0 && dest_y < surface_data->height) {
-                    int src_x = sx + ix;
-                    int src_y = sy + iy;
-
-                    Uint8 color = src_ptr[static_cast<size_t>(src_x + (src_y * surface_data_->width))];
-                    if (color != static_cast<Uint8>(transparent_color_)) {
-                        dst_ptr[static_cast<size_t>(dest_x + (dest_y * surface_data->width))] = sub_palette_[color];
-                    }
-                }
-            }
+        if (e2 < DX) {
+            err += DX;
+            iy1 += SY;
        }
    }
 }
@@ -283,18 +253,14 @@ void Surface::render(int x, int y, SDL_FRect* src_rect, SDL_FlipMode flip) {  //
    // Determina la región de origen (clip) a renderizar
    float sx = (src_rect != nullptr) ? src_rect->x : 0;
    float sy = (src_rect != nullptr) ? src_rect->y : 0;
-    float w = (src_rect != nullptr) ? src_rect->w : surface_data_->width;
-    float h = (src_rect != nullptr) ? src_rect->h : surface_data_->height;
+    float w = (src_rect != nullptr) ? src_rect->w : static_cast<float>(surface_data_->width);
+    float h = (src_rect != nullptr) ? src_rect->h : static_cast<float>(surface_data_->height);

-    // Limitar la región para evitar accesos fuera de rango en origen
-    w = std::min(w, surface_data_->width - sx);
-    h = std::min(h, surface_data_->height - sy);
-    w = std::min(w, surface_data_dest->width - x);
-    h = std::min(h, surface_data_dest->height - y);
-
-    // Limitar la región para evitar accesos fuera de rango en destino
-    w = std::min(w, surface_data_dest->width - x);
-    h = std::min(h, surface_data_dest->height - y);
+    // Limitar la región para evitar accesos fuera de rango (origen y destino)
+    w = std::min(w, static_cast<float>(surface_data_->width) - sx);
+    h = std::min(h, static_cast<float>(surface_data_->height) - sy);
+    w = std::min(w, static_cast<float>(surface_data_dest->width - x));
+    h = std::min(h, static_cast<float>(surface_data_dest->height - y));

    // Renderiza píxel por píxel aplicando el flip si es necesario
    const Uint8* src_ptr = surface_data_->data.get();
@@ -322,7 +288,7 @@ void Surface::render(int x, int y, SDL_FRect* src_rect, SDL_FlipMode flip) {  //
 }

 // Helper para calcular coordenadas con flip
-void Surface::calculateFlippedCoords(int ix, int iy, float sx, float sy, float w, float h, SDL_FlipMode flip, int& src_x, int& src_y) {
+void Surface::calculateFlippedCoords(int ix, int iy, int sx, int sy, int w, int h, SDL_FlipMode flip, int& src_x, int& src_y) {
    src_x = (flip == SDL_FLIP_HORIZONTAL) ? (sx + w - 1 - ix) : (sx + ix);
    src_y = (flip == SDL_FLIP_VERTICAL) ? (sy + h - 1 - iy) : (sy + iy);
 }
@@ -418,11 +384,11 @@ void Surface::renderWithColorReplace(int x, int y, Uint8 source_color, Uint8 tar
                continue;  // Saltar píxeles fuera del rango del destino
            }

-            // Copia el píxel si no es transparente
+            // Copia el píxel si no es transparente; aplica sub_palette_ como el resto de render*
            Uint8 color = surface_data_->data.get()[static_cast<size_t>(src_x + (src_y * surface_data_->width))];
            if (color != static_cast<Uint8>(transparent_color_)) {
                surface_data->data[dest_x + (dest_y * surface_data->width)] =
-                    (color == source_color) ? target_color : color;
+                    (color == source_color) ? target_color : sub_palette_[color];
            }
        }
    }
@@ -452,14 +418,14 @@ static auto computeFadeDensity(int screen_y, int fade_h, int canvas_height) -> f
 void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height, SDL_FRect* src_rect) const {
    const int SX = (src_rect != nullptr) ? static_cast<int>(src_rect->x) : 0;
    const int SY = (src_rect != nullptr) ? static_cast<int>(src_rect->y) : 0;
-    const int SW = (src_rect != nullptr) ? static_cast<int>(src_rect->w) : static_cast<int>(surface_data_->width);
-    const int SH = (src_rect != nullptr) ? static_cast<int>(src_rect->h) : static_cast<int>(surface_data_->height);
+    const int SW = (src_rect != nullptr) ? static_cast<int>(src_rect->w) : surface_data_->width;
+    const int SH = (src_rect != nullptr) ? static_cast<int>(src_rect->h) : surface_data_->height;

    auto surface_data_dest = Screen::get()->getRendererSurface()->getSurfaceData();

    for (int row = 0; row < SH; row++) {
        const int SCREEN_Y = y + row;
-        if (SCREEN_Y < 0 || SCREEN_Y >= static_cast<int>(surface_data_dest->height)) {
+        if (SCREEN_Y < 0 || SCREEN_Y >= surface_data_dest->height) {
            continue;
        }

@@ -467,11 +433,11 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height

        for (int col = 0; col < SW; col++) {
            const int SCREEN_X = x + col;
-            if (SCREEN_X < 0 || SCREEN_X >= static_cast<int>(surface_data_dest->width)) {
+            if (SCREEN_X < 0 || SCREEN_X >= surface_data_dest->width) {
                continue;
            }

-            const Uint8 COLOR = surface_data_->data[((SY + row) * static_cast<int>(surface_data_->width)) + (SX + col)];
+            const Uint8 COLOR = surface_data_->data[((SY + row) * surface_data_->width) + (SX + col)];
            if (COLOR == static_cast<Uint8>(transparent_color_)) {
                continue;
            }
@@ -480,7 +446,7 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height
                continue;  // Pixel tapat per la zona de fade
            }

-            surface_data_dest->data[SCREEN_X + (SCREEN_Y * static_cast<int>(surface_data_dest->width))] = sub_palette_[COLOR];
+            surface_data_dest->data[SCREEN_X + (SCREEN_Y * surface_data_dest->width)] = sub_palette_[COLOR];
        }
    }
 }
@@ -489,14 +455,14 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height
 void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height, Uint8 source_color, Uint8 target_color, SDL_FRect* src_rect) const {
    const int SX = (src_rect != nullptr) ? static_cast<int>(src_rect->x) : 0;
    const int SY = (src_rect != nullptr) ? static_cast<int>(src_rect->y) : 0;
-    const int SW = (src_rect != nullptr) ? static_cast<int>(src_rect->w) : static_cast<int>(surface_data_->width);
-    const int SH = (src_rect != nullptr) ? static_cast<int>(src_rect->h) : static_cast<int>(surface_data_->height);
+    const int SW = (src_rect != nullptr) ? static_cast<int>(src_rect->w) : surface_data_->width;
+    const int SH = (src_rect != nullptr) ? static_cast<int>(src_rect->h) : surface_data_->height;

    auto surface_data_dest = Screen::get()->getRendererSurface()->getSurfaceData();

    for (int row = 0; row < SH; row++) {
        const int SCREEN_Y = y + row;
-        if (SCREEN_Y < 0 || SCREEN_Y >= static_cast<int>(surface_data_dest->height)) {
+        if (SCREEN_Y < 0 || SCREEN_Y >= surface_data_dest->height) {
            continue;
        }

@@ -504,11 +470,11 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height

        for (int col = 0; col < SW; col++) {
            const int SCREEN_X = x + col;
-            if (SCREEN_X < 0 || SCREEN_X >= static_cast<int>(surface_data_dest->width)) {
+            if (SCREEN_X < 0 || SCREEN_X >= surface_data_dest->width) {
                continue;
            }

-            const Uint8 COLOR = surface_data_->data[((SY + row) * static_cast<int>(surface_data_->width)) + (SX + col)];
+            const Uint8 COLOR = surface_data_->data[((SY + row) * surface_data_->width) + (SX + col)];
            if (COLOR == static_cast<Uint8>(transparent_color_)) {
                continue;
            }
@@ -518,7 +484,7 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height
            }

            const Uint8 OUT_COLOR = (COLOR == source_color) ? target_color : sub_palette_[COLOR];
-            surface_data_dest->data[SCREEN_X + (SCREEN_Y * static_cast<int>(surface_data_dest->width))] = OUT_COLOR;
+            surface_data_dest->data[SCREEN_X + (SCREEN_Y * surface_data_dest->width)] = OUT_COLOR;
        }
    }
 }
@@ -527,8 +493,8 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height
 void Surface::toARGBBuffer(Uint32* buffer) const {
    if (!surface_data_ || !surface_data_->data || (buffer == nullptr)) { return; }

-    const int WIDTH = static_cast<int>(surface_data_->width);
-    const int HEIGHT = static_cast<int>(surface_data_->height);
+    const int WIDTH = surface_data_->width;
+    const int HEIGHT = surface_data_->height;
    const Uint8* src = surface_data_->data.get();

    // Obtenemos el tamaño de la paleta para evitar accesos fuera de rango
@@ -639,11 +605,8 @@ void Surface::copyToTexture(SDL_Renderer* renderer, SDL_Texture* texture, SDL_FR

 // Realiza un efecto de fundido en la paleta principal
 auto Surface::fadePalette() -> bool {  // NOLINT(readability-convert-member-functions-to-static)
-    // Verificar que el tamaño mínimo de palette_ sea adecuado
    static constexpr int PALETTE_SIZE = 19;
-    if (sizeof(palette_) / sizeof(palette_[0]) < PALETTE_SIZE) {
-        throw std::runtime_error("Palette size is insufficient for fadePalette operation.");
-    }
+    static_assert(std::tuple_size_v<Palette> >= PALETTE_SIZE, "Palette size is insufficient for fadePalette operation.");

    // Desplazar colores (pares e impares)
    for (int i = 18; i > 1; --i) {
@@ -673,11 +636,8 @@ auto Surface::fadeSubPalette(Uint32 delay) -> bool {  // NOLINT(readability-conv
    // Actualizar el último tick
    last_tick_ = current_tick;

-    // Verificar que el tamaño mínimo de sub_palette_ sea adecuado
    static constexpr int SUB_PALETTE_SIZE = 19;
-    if (sizeof(sub_palette_) / sizeof(sub_palette_[0]) < SUB_PALETTE_SIZE) {
-        throw std::runtime_error("Palette size is insufficient for fadePalette operation.");
-    }
+    static_assert(std::tuple_size_v<SubPalette> >= SUB_PALETTE_SIZE, "Sub-palette size is insufficient for fadeSubPalette operation.");

    // Desplazar colores (pares e impares)
    for (int i = 18; i > 1; --i) {
--- a/source/core/rendering/surface.hpp
+++ b/source/core/rendering/surface.hpp
@@ -22,8 +22,8 @@ auto readPalFile(const std::string& file_path) -> Palette;

 struct SurfaceData {
    std::shared_ptr<Uint8[]> data;  // Usa std::shared_ptr para gestión automática
-    float width;                    // Ancho de la imagen
-    float height;                   // Alto de la imagen
+    int width;                      // Ancho de la imagen
+    int height;                     // Alto de la imagen

    // Constructor por defecto
    SurfaceData()
@@ -32,13 +32,13 @@ struct SurfaceData {
          height(0) {}

    // Constructor que inicializa dimensiones y asigna memoria
-    SurfaceData(float w, float h)
-        : data(std::shared_ptr<Uint8[]>(new Uint8[static_cast<size_t>(w * h)](), std::default_delete<Uint8[]>())),
+    SurfaceData(int w, int h)
+        : data(std::shared_ptr<Uint8[]>(new Uint8[static_cast<size_t>(w) * static_cast<size_t>(h)](), std::default_delete<Uint8[]>())),
          width(w),
          height(h) {}

    // Constructor para inicializar directamente con datos
-    SurfaceData(float w, float h, std::shared_ptr<Uint8[]> pixels)
+    SurfaceData(int w, int h, std::shared_ptr<Uint8[]> pixels)
        : data(std::move(pixels)),
          width(w),
          height(h) {}
@@ -56,6 +56,9 @@ struct SurfaceData {

 class Surface {
   private:
+    // shared_ptr porque render() accede al SurfaceData propio y al del renderer
+    // surface (ver getRendererSurface()) de forma efímera; con self-blit ambos
+    // pueden alias y el refcount evita free accidental durante el recorrido.
    std::shared_ptr<SurfaceData> surface_data_;  // Datos a dibujar
    Palette palette_;                            // Paleta para volcar la SurfaceData a una Textura
    SubPalette sub_palette_;                     // Paleta para reindexar colores
@@ -77,7 +80,6 @@ class Surface {
    void loadPalette(const Palette& palette);

    // Copia una región de la SurfaceData de origen a la SurfaceData de destino
-    void render(float dx, float dy, float sx, float sy, float w, float h);
    void render(int x, int y, SDL_FRect* src_rect = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE);
    void render(SDL_FRect* src_rect = nullptr, SDL_FRect* dst_rect = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE);

@@ -127,11 +129,10 @@ class Surface {

    // Metodos para gestionar surface_data_
    [[nodiscard]] auto getSurfaceData() const -> std::shared_ptr<SurfaceData> { return surface_data_; }
-    void setSurfaceData(std::shared_ptr<SurfaceData> new_data) { surface_data_ = std::move(new_data); }

    // Obtien ancho y alto
-    [[nodiscard]] auto getWidth() const -> float { return surface_data_->width; }
-    [[nodiscard]] auto getHeight() const -> float { return surface_data_->height; }
+    [[nodiscard]] auto getWidth() const -> int { return surface_data_->width; }
+    [[nodiscard]] auto getHeight() const -> int { return surface_data_->height; }

    // Color transparente
    [[nodiscard]] auto getTransparentColor() const -> Uint8 { return transparent_color_; }
@@ -146,7 +147,7 @@ class Surface {

   private:
    // Helper para calcular coordenadas con flip
-    static void calculateFlippedCoords(int ix, int iy, float sx, float sy, float w, float h, SDL_FlipMode flip, int& src_x, int& src_y);
+    static void calculateFlippedCoords(int ix, int iy, int sx, int sy, int w, int h, SDL_FlipMode flip, int& src_x, int& src_y);

    // Helper para copiar un pixel si no es transparente
    void copyPixelIfNotTransparent(Uint8* dest_data, int dest_x, int dest_y, int dest_width, int src_x, int src_y) const;
--- a/source/core/resources/resource_cache.cpp
+++ b/source/core/resources/resource_cache.cpp
@@ -645,14 +645,20 @@ namespace Resource {

    // Muestra el progreso de carga
    void Cache::renderProgress() {
+        Screen::get()->start();
+        Screen::get()->clearSurface(static_cast<Uint8>(PaletteColor::BLACK));
+
+        // Si show=false: pantalla negra y salir
+        if (!Options::loading.show) {
+            Screen::get()->render();
+            return;
+        }
+
        constexpr float X_PADDING = 60.0F;
        constexpr float Y_PADDING = 10.0F;
        constexpr float BAR_HEIGHT = 5.0F;

        const float BAR_POSITION = Options::game.height - BAR_HEIGHT - Y_PADDING;
-        Screen::get()->start();
-        Screen::get()->clearSurface(static_cast<Uint8>(PaletteColor::BLACK));
-
        auto surface = Screen::get()->getRendererSurface();
        const auto LOADING_TEXT_COLOR = static_cast<Uint8>(PaletteColor::BRIGHT_WHITE);
        const auto BAR_COLOR = static_cast<Uint8>(PaletteColor::WHITE);
@@ -686,13 +692,15 @@ namespace Resource {
        SDL_FRect rect_full = {.x = X_PADDING, .y = BAR_POSITION, .w = FULL_BAR_WIDTH, .h = BAR_HEIGHT};
        surface->fillRect(&rect_full, BAR_COLOR);

-        // Mostra el nom del recurs que està a punt de carregar-se, centrat sobre la barra
-        if (!current_loading_name_.empty()) {
+        // Mostra el nom del recurs (o missatge d'espera si ja ha acabat i wait_for_input=true)
+        const bool WAITING_FOR_INPUT = isLoadDone() && Options::loading.wait_for_input;
+        const std::string OVER_BAR_TEXT = WAITING_FOR_INPUT ? "PRESS ANY KEY TO CONTINUE" : current_loading_name_;
+        if ((Options::loading.show_resource_name || WAITING_FOR_INPUT) && !OVER_BAR_TEXT.empty()) {
            const float TEXT_Y = BAR_POSITION - static_cast<float>(TEXT_HEIGHT) - 2.0F;
            loading_text_->writeColored(
-                CENTER_X - (loading_text_->length(current_loading_name_) / 2),
+                CENTER_X - (loading_text_->length(OVER_BAR_TEXT) / 2),
                static_cast<int>(TEXT_Y),
-                current_loading_name_,
+                OVER_BAR_TEXT,
                LOADING_TEXT_COLOR);
        }

--- a/source/core/system/director.cpp
+++ b/source/core/system/director.cpp
@@ -438,7 +438,11 @@ auto Director::iterate() -> SDL_AppResult {
            // per veure la barra avançar suau i processar events del WM/ESC,
            // i evita el 50% d'ineficiència que provocaria un budget < vsync.
            if (Resource::Cache::get()->loadStep(50 /*ms*/)) {
-                finishBoot();
+                if (Options::loading.show && Options::loading.wait_for_input) {
+                    boot_waiting_for_input_ = true;  // Esperar tecla antes de continuar
+                } else {
+                    finishBoot();
+                }
                boot_loading_ = false;
                // finishBoot() ja ha fixat SceneManager::current a LOGO (o la que
                // digui Debug). El canvi d'escena es fa just a sota.
@@ -472,6 +476,17 @@ auto Director::handleEvent(const SDL_Event& event) -> SDL_AppResult {
    }
 #endif

+    // Si estamos esperando input tras la carga: consumir tecla/botón y arrancar
+    if (boot_waiting_for_input_) {
+        const bool IS_KEY = event.type == SDL_EVENT_KEY_DOWN && !event.key.repeat;
+        const bool IS_BUTTON = event.type == SDL_EVENT_GAMEPAD_BUTTON_DOWN;
+        if (IS_KEY || IS_BUTTON) {
+            boot_waiting_for_input_ = false;
+            finishBoot();
+        }
+        return SDL_APP_CONTINUE;
+    }
+
    if (active_scene_) {
        active_scene_->handleEvent(event);
    }
--- a/source/core/system/director.hpp
+++ b/source/core/system/director.hpp
@@ -25,6 +25,7 @@ class Director {
    std::unique_ptr<Scene> active_scene_;                                  // Escena activa
    SceneManager::Scene current_scene_{SceneManager::Scene::BOOT_LOADER};  // Tipus d'escena activa
    bool boot_loading_{true};                                              // True mientras Cache::loadStep() no haya acabado
+    bool boot_waiting_for_input_{false};                                   // True si la carga acabó y Options::loading.wait_for_input está activo

    // --- Funciones ---
    void createSystemFolder(const std::string& folder);  // Crea la carpeta del sistema donde guardar datos
--- a/source/external/stb_vorbis.c
+++ b/source/external/stb_vorbis.c
@@ -1,4 +1,4 @@
-// Ogg Vorbis audio decoder - v1.20 - public domain
+// Ogg Vorbis audio decoder - v1.22 - public domain
 // http://nothings.org/stb_vorbis/
 //
 // Original version written by Sean Barrett in 2007.
@@ -29,12 +29,15 @@
 //    Bernhard Wodo      Evan Balster        github:alxprd
 //    Tom Beaumont       Ingo Leitgeb        Nicolas Guillemot
 //    Phillip Bennefall  Rohit               Thiago Goulart
-//    github:manxorist   saga musix          github:infatum
+//    github:manxorist   Saga Musix          github:infatum
 //    Timur Gagiev       Maxwell Koo         Peter Waller
 //    github:audinowho   Dougall Johnson     David Reid
 //    github:Clownacy    Pedro J. Estebanez  Remi Verschelde
+//    AnthoFoxo          github:morlat       Gabriel Ravier
 //
 // Partial history:
+//    1.22    - 2021-07-11 - various small fixes
+//    1.21    - 2021-07-02 - fix bug for files with no comments
 //    1.20    - 2020-07-11 - several small fixes
 //    1.19    - 2020-02-05 - warnings
 //    1.18    - 2020-02-02 - fix seek bugs; parse header comments; misc warnings etc.
@@ -220,6 +223,12 @@ extern int stb_vorbis_decode_frame_pushdata(
 // channel. In other words, (*output)[0][0] contains the first sample from
 // the first channel, and (*output)[1][0] contains the first sample from
 // the second channel.
+//
+// *output points into stb_vorbis's internal output buffer storage; these
+// buffers are owned by stb_vorbis and application code should not free
+// them or modify their contents. They are transient and will be overwritten
+// once you ask for more data to get decoded, so be sure to grab any data
+// you need before then.

 extern void stb_vorbis_flush_pushdata(stb_vorbis *f);
 // inform stb_vorbis that your next datablock will not be contiguous with
@@ -579,7 +588,7 @@ enum STBVorbisError
   #if defined(_MSC_VER) || defined(__MINGW32__)
      #include <malloc.h>
   #endif
-   #if defined(__linux__) || defined(__linux) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__)
+   #if defined(__linux__) || defined(__linux) || defined(__sun__) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__)
      #include <alloca.h>
   #endif
 #else // STB_VORBIS_NO_CRT
@@ -646,6 +655,12 @@ typedef   signed int    int32;

 typedef float codetype;

+#ifdef _MSC_VER
+#define STBV_NOTUSED(v)  (void)(v)
+#else
+#define STBV_NOTUSED(v)  (void)sizeof(v)
+#endif
+
 // @NOTE
 //
 // Some arrays below are tagged "//varies", which means it's actually
@@ -1046,7 +1061,7 @@ static float float32_unpack(uint32 x)
   uint32 sign = x & 0x80000000;
   uint32 exp = (x & 0x7fe00000) >> 21;
   double res = sign ? -(double)mantissa : (double)mantissa;
-   return (float) ldexp((float)res, exp-788);
+   return (float) ldexp((float)res, (int)exp-788);
 }


@@ -1077,6 +1092,7 @@ static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)
   // find the first entry
   for (k=0; k < n; ++k) if (len[k] < NO_CODE) break;
   if (k == n) { assert(c->sorted_entries == 0); return TRUE; }
+   assert(len[k] < 32); // no error return required, code reading lens checks this
   // add to the list
   add_entry(c, 0, k, m++, len[k], values);
   // add all available leaves
@@ -1090,6 +1106,7 @@ static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)
      uint32 res;
      int z = len[i], y;
      if (z == NO_CODE) continue;
+      assert(z < 32); // no error return required, code reading lens checks this
      // find lowest available leaf (should always be earliest,
      // which is what the specification calls for)
      // note that this property, and the fact we can never have
@@ -1099,12 +1116,10 @@ static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)
      while (z > 0 && !available[z]) --z;
      if (z == 0) { return FALSE; }
      res = available[z];
-      assert(z >= 0 && z < 32);
      available[z] = 0;
      add_entry(c, bit_reverse(res), i, m++, len[i], values);
      // propagate availability up the tree
      if (z != len[i]) {
-         assert(len[i] >= 0 && len[i] < 32);
         for (y=len[i]; y > z; --y) {
            assert(available[y] == 0);
            available[y] = res + (1 << (32-y));
@@ -2577,34 +2592,33 @@ static void imdct_step3_inner_s_loop_ld654(int n, float *e, int i_off, float *A,

   while (z > base) {
      float k00,k11;
+      float l00,l11;

-      k00   = z[-0] - z[-8];
-      k11   = z[-1] - z[-9];
-      z[-0] = z[-0] + z[-8];
-      z[-1] = z[-1] + z[-9];
-      z[-8] =  k00;
-      z[-9] =  k11 ;
+      k00    = z[-0] - z[ -8];
+      k11    = z[-1] - z[ -9];
+      l00    = z[-2] - z[-10];
+      l11    = z[-3] - z[-11];
+      z[ -0] = z[-0] + z[ -8];
+      z[ -1] = z[-1] + z[ -9];
+      z[ -2] = z[-2] + z[-10];
+      z[ -3] = z[-3] + z[-11];
+      z[ -8] = k00;
+      z[ -9] = k11;
+      z[-10] = (l00+l11) * A2;
+      z[-11] = (l11-l00) * A2;

-      k00    = z[ -2] - z[-10];
-      k11    = z[ -3] - z[-11];
-      z[ -2] = z[ -2] + z[-10];
-      z[ -3] = z[ -3] + z[-11];
-      z[-10] = (k00+k11) * A2;
-      z[-11] = (k11-k00) * A2;
-
-      k00    = z[-12] - z[ -4];  // reverse to avoid a unary negation
+      k00    = z[ -4] - z[-12];
      k11    = z[ -5] - z[-13];
+      l00    = z[ -6] - z[-14];
+      l11    = z[ -7] - z[-15];
      z[ -4] = z[ -4] + z[-12];
      z[ -5] = z[ -5] + z[-13];
-      z[-12] = k11;
-      z[-13] = k00;
-
-      k00    = z[-14] - z[ -6];  // reverse to avoid a unary negation
-      k11    = z[ -7] - z[-15];
      z[ -6] = z[ -6] + z[-14];
      z[ -7] = z[ -7] + z[-15];
-      z[-14] = (k00+k11) * A2;
-      z[-15] = (k00-k11) * A2;
+      z[-12] = k11;
+      z[-13] = -k00;
+      z[-14] = (l11-l00) * A2;
+      z[-15] = (l00+l11) * -A2;

      iter_54(z);
      iter_54(z-8);
@@ -3069,6 +3083,7 @@ static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *f
      for (q=1; q < g->values; ++q) {
         j = g->sorted_order[q];
         #ifndef STB_VORBIS_NO_DEFER_FLOOR
+         STBV_NOTUSED(step2_flag);
         if (finalY[j] >= 0)
         #else
         if (step2_flag[j])
@@ -3171,6 +3186,7 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start,

 // WINDOWING

+   STBV_NOTUSED(left_end);
   n = f->blocksize[m->blockflag];
   map = &f->mapping[m->mapping];

@@ -3368,7 +3384,7 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start,
      // this isn't to spec, but spec would require us to read ahead
      // and decode the size of all current frames--could be done,
      // but presumably it's not a commonly used feature
-      f->current_loc = -n2; // start of first frame is positioned for discard
+      f->current_loc = 0u - n2; // start of first frame is positioned for discard (NB this is an intentional unsigned overflow/wrap-around)
      // we might have to discard samples "from" the next frame too,
      // if we're lapping a large block then a small at the start?
      f->discard_samples_deferred = n - right_end;
@@ -3642,9 +3658,11 @@ static int start_decoder(vorb *f)
   f->vendor[len] = (char)'\0';
   //user comments
   f->comment_list_length = get32_packet(f);
-   if (f->comment_list_length > 0) {
-        f->comment_list = (char**)setup_malloc(f, sizeof(char*) * (f->comment_list_length));
-        if (f->comment_list == NULL)                     return error(f, VORBIS_outofmem);
+   f->comment_list = NULL;
+   if (f->comment_list_length > 0)
+   {
+      f->comment_list = (char**) setup_malloc(f, sizeof(char*) * (f->comment_list_length));
+      if (f->comment_list == NULL)                  return error(f, VORBIS_outofmem);
   }

   for(i=0; i < f->comment_list_length; ++i) {
@@ -3867,8 +3885,7 @@ static int start_decoder(vorb *f)
               unsigned int div=1;
               for (k=0; k < c->dimensions; ++k) {
                  int off = (z / div) % c->lookup_values;
-                  float val = mults[off];
-                  val = mults[off]*c->delta_value + c->minimum_value + last;
+                  float val = mults[off]*c->delta_value + c->minimum_value + last;
                  c->multiplicands[j*c->dimensions + k] = val;
                  if (c->sequence_p)
                     last = val;
@@ -3951,7 +3968,7 @@ static int start_decoder(vorb *f)
               if (g->class_masterbooks[j] >= f->codebook_count) return error(f, VORBIS_invalid_setup);
            }
            for (k=0; k < 1 << g->class_subclasses[j]; ++k) {
-               g->subclass_books[j][k] = get_bits(f,8)-1;
+               g->subclass_books[j][k] = (int16)get_bits(f,8)-1;
               if (g->subclass_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup);
            }
         }
@@ -4509,6 +4526,7 @@ stb_vorbis *stb_vorbis_open_pushdata(
         *error = VORBIS_need_more_data;
      else
         *error = p.error;
+      vorbis_deinit(&p);
      return NULL;
   }
   f = vorbis_alloc(&p);
@@ -4566,7 +4584,7 @@ static uint32 vorbis_find_page(stb_vorbis *f, uint32 *end, uint32 *last)
               header[i] = get8(f);
            if (f->eof) return 0;
            if (header[4] != 0) goto invalid;
-            goal = header[22] + (header[23] << 8) + (header[24]<<16) + (header[25]<<24);
+            goal = header[22] + (header[23] << 8) + (header[24]<<16) + ((uint32)header[25]<<24);
            for (i=22; i < 26; ++i)
               header[i] = 0;
            crc = 0;
@@ -4970,7 +4988,7 @@ unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f)
            // set. whoops!
            break;
         }
-         previous_safe = last_page_loc+1;
+         //previous_safe = last_page_loc+1; // NOTE: not used after this point, but note for debugging
         last_page_loc = stb_vorbis_get_file_offset(f);
      }

@@ -5081,7 +5099,10 @@ stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, const st
 stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, const stb_vorbis_alloc *alloc)
 {
   stb_vorbis *f, p;
-   if (data == NULL) return NULL;
+   if (!data) {
+      if (error) *error = VORBIS_unexpected_eof;
+      return NULL;
+   }
   vorbis_init(&p, alloc);
   p.stream = (uint8 *) data;
   p.stream_end = (uint8 *) data + len;
@@ -5156,11 +5177,11 @@ static void copy_samples(short *dest, float *src, int len)

 static void compute_samples(int mask, short *output, int num_c, float **data, int d_offset, int len)
 {
-   #define BUFFER_SIZE  32
-   float buffer[BUFFER_SIZE];
-   int i,j,o,n = BUFFER_SIZE;
+   #define STB_BUFFER_SIZE  32
+   float buffer[STB_BUFFER_SIZE];
+   int i,j,o,n = STB_BUFFER_SIZE;
   check_endianness();
-   for (o = 0; o < len; o += BUFFER_SIZE) {
+   for (o = 0; o < len; o += STB_BUFFER_SIZE) {
      memset(buffer, 0, sizeof(buffer));
      if (o + n > len) n = len - o;
      for (j=0; j < num_c; ++j) {
@@ -5177,16 +5198,17 @@ static void compute_samples(int mask, short *output, int num_c, float **data, in
         output[o+i] = v;
      }
   }
+   #undef STB_BUFFER_SIZE
 }

 static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len)
 {
-   #define BUFFER_SIZE  32
-   float buffer[BUFFER_SIZE];
-   int i,j,o,n = BUFFER_SIZE >> 1;
+   #define STB_BUFFER_SIZE  32
+   float buffer[STB_BUFFER_SIZE];
+   int i,j,o,n = STB_BUFFER_SIZE >> 1;
   // o is the offset in the source data
   check_endianness();
-   for (o = 0; o < len; o += BUFFER_SIZE >> 1) {
+   for (o = 0; o < len; o += STB_BUFFER_SIZE >> 1) {
      // o2 is the offset in the output data
      int o2 = o << 1;
      memset(buffer, 0, sizeof(buffer));
@@ -5216,6 +5238,7 @@ static void compute_stereo_samples(short *output, int num_c, float **data, int d
         output[o2+i] = v;
      }
   }
+   #undef STB_BUFFER_SIZE
 }

 static void convert_samples_short(int buf_c, short **buffer, int b_offset, int data_c, float **data, int d_offset, int samples)
@@ -5288,8 +5311,6 @@ int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short
   float **outputs;
   int len = num_shorts / channels;
   int n=0;
-   int z = f->channels;
-   if (z > channels) z = channels;
   while (n < len) {
      int k = f->channel_buffer_end - f->channel_buffer_start;
      if (n+k >= len) k = len - n;
@@ -5308,8 +5329,6 @@ int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, in
 {
   float **outputs;
   int n=0;
-   int z = f->channels;
-   if (z > channels) z = channels;
   while (n < len) {
      int k = f->channel_buffer_end - f->channel_buffer_start;
      if (n+k >= len) k = len - n;
--- a/source/game/defaults.hpp
+++ b/source/game/defaults.hpp
@@ -89,6 +89,12 @@ namespace Defaults::Localization {
    constexpr const char* LANGUAGE = "ca";  // Idioma por defecto (en = inglés, ca = catalán)
 }  // namespace Defaults::Localization

+namespace Defaults::Loading {
+    constexpr bool SHOW = false;               // No mostrar la pantalla de carga por defecto
+    constexpr bool SHOW_RESOURCE_NAME = true;  // Mostrar el nombre del recurso por defecto
+    constexpr bool WAIT_FOR_INPUT = false;     // No esperar tecla al terminar por defecto
+}  // namespace Defaults::Loading
+
 namespace Defaults::Game::Items {
    constexpr const float PERCENT_TO_OPEN_THE_JAIL = 0.9F;  // Porcentaje de items necesarios para abrir la jail
 }  // namespace Defaults::Game::Items
--- a/source/game/editor/mini_map.cpp
+++ b/source/game/editor/mini_map.cpp
@@ -39,9 +39,9 @@ void MiniMap::buildTileColorTable(const std::string& tileset_name) {
    auto tileset = Resource::Cache::get()->getSurface(tileset_name);
    if (!tileset) { return; }

-    tileset_width_ = static_cast<int>(tileset->getWidth()) / Tile::SIZE;
+    tileset_width_ = tileset->getWidth() / Tile::SIZE;
    tileset_transparent_ = tileset->getTransparentColor();
-    int tileset_height = static_cast<int>(tileset->getHeight()) / Tile::SIZE;
+    int tileset_height = tileset->getHeight() / Tile::SIZE;
    int total_tiles = tileset_width_ * tileset_height;

    tile_colors_.resize(total_tiles, 0);
--- a/source/game/editor/tile_picker.cpp
+++ b/source/game/editor/tile_picker.cpp
@@ -26,8 +26,8 @@ void TilePicker::open(const std::string& tileset_name, int current_tile, int bg_

    // Calcular dimensiones del tileset en tiles (teniendo en cuenta spacing de entrada)
    int src_cell = Tile::SIZE + spacing_in_;
-    tileset_width_ = static_cast<int>(tileset_->getWidth()) / src_cell;
-    tileset_height_ = static_cast<int>(tileset_->getHeight()) / src_cell;
+    tileset_width_ = tileset_->getWidth() / src_cell;
+    tileset_height_ = tileset_->getHeight() / src_cell;
    // Corregir si el último tile cabe sin spacing
    if (tileset_width_ == 0 && tileset_->getWidth() >= Tile::SIZE) { tileset_width_ = 1; }
    if (tileset_height_ == 0 && tileset_->getHeight() >= Tile::SIZE) { tileset_height_ = 1; }
--- a/source/game/options.cpp
+++ b/source/game/options.cpp
@@ -623,6 +623,27 @@ namespace Options {
        }
    }

+    // Carga opciones de la pantalla de carga desde YAML
+    void loadLoadingFromYaml(const fkyaml::node& yaml) {
+        if (!yaml.contains("loading")) { return; }
+        const auto& ld = yaml["loading"];
+        if (ld.contains("show")) {
+            try {
+                loading.show = ld["show"].get_value<bool>();
+            } catch (...) { loading.show = Defaults::Loading::SHOW; }
+        }
+        if (ld.contains("show_resource_name")) {
+            try {
+                loading.show_resource_name = ld["show_resource_name"].get_value<bool>();
+            } catch (...) { loading.show_resource_name = Defaults::Loading::SHOW_RESOURCE_NAME; }
+        }
+        if (ld.contains("wait_for_input")) {
+            try {
+                loading.wait_for_input = ld["wait_for_input"].get_value<bool>();
+            } catch (...) { loading.wait_for_input = Defaults::Loading::WAIT_FOR_INPUT; }
+        }
+    }
+
    // Establece la ruta del fichero de configuración
    void setConfigFile(const std::string& path) {
        config_file_path = path;
@@ -673,6 +694,7 @@ namespace Options {
            loadPlayerConfigFromYaml(yaml);
            loadKioskConfigFromYaml(yaml);
            loadLocalizationFromYaml(yaml);
+            loadLoadingFromYaml(yaml);

            std::cout << "Config file loaded successfully\n\n";

@@ -810,6 +832,14 @@ namespace Options {
        file << "localization:\n";
        file << "  language: \"" << language << "\"\n";

+        // LOADING SCREEN
+        file << "\n";
+        file << "# LOADING SCREEN\n";
+        file << "loading:\n";
+        file << "  show: " << (loading.show ? "true" : "false") << "\n";
+        file << "  show_resource_name: " << (loading.show_resource_name ? "true" : "false") << "\n";
+        file << "  wait_for_input: " << (loading.wait_for_input ? "true" : "false") << " # solo si show=true\n";
+
        file.close();

        std::cout << "Config file saved successfully\n\n";
--- a/source/game/options.hpp
+++ b/source/game/options.hpp
@@ -134,6 +134,13 @@ namespace Options {
        float volume{Defaults::Audio::VOLUME};   // Volumen al que suenan el audio (0-128 internamente)
    };

+    // Estructura para las opciones de la pantalla de carga
+    struct Loading {
+        bool show{Defaults::Loading::SHOW};                              // Muestra la pantalla de carga (si no, pantalla en negro)
+        bool show_resource_name{Defaults::Loading::SHOW_RESOURCE_NAME};  // Muestra el nombre del recurso sobre la barra de progreso
+        bool wait_for_input{Defaults::Loading::WAIT_FOR_INPUT};          // Al terminar la carga, espera tecla antes de continuar (solo si show=true)
+    };
+
    // Estructura para las opciones de juego
    struct Game {
        float width{Defaults::Canvas::WIDTH};                   // Ancho de la resolucion del juego
@@ -182,6 +189,7 @@ namespace Options {
    inline Stats stats{};                         // Datos con las estadisticas de juego
    inline Window window{};                       // Opciones relativas a la ventana
    inline Audio audio{};                         // Opciones relativas al audio
+    inline Loading loading{};                     // Opciones de la pantalla de carga
    inline KeyboardControls keyboard_controls{};  // Teclas usadas para jugar
    inline GamepadControls gamepad_controls{};    // Botones del gamepad usados para jugar
    inline Kiosk kiosk{};                         // Opciones del modo kiosko
--- a/source/game/scenes/title.cpp
+++ b/source/game/scenes/title.cpp
@@ -502,7 +502,7 @@ void Title::createCheevosTexture() {  // NOLINT(readability-convert-member-funct

    // Crea el sprite para el listado de logros (usa la zona del menu)
    cheevos_sprite_ = std::make_unique<Sprite>(cheevos_surface_, (GameCanvas::WIDTH - cheevos_surface_->getWidth()) / 2, MENU_ZONE_Y, cheevos_surface_->getWidth(), cheevos_surface_->getHeight());
-    cheevos_surface_view_ = {.x = 0, .y = 0, .w = cheevos_surface_->getWidth(), .h = CHEEVOS_TEXTURE_VIEW_HEIGHT};
+    cheevos_surface_view_ = {.x = 0, .y = 0, .w = static_cast<float>(cheevos_surface_->getWidth()), .h = CHEEVOS_TEXTURE_VIEW_HEIGHT};
    cheevos_sprite_->setClip(cheevos_surface_view_);
 }

--- a/source/game/ui/notifier.cpp
+++ b/source/game/ui/notifier.cpp
@@ -225,7 +225,7 @@ void Notifier::show(std::vector<std::string> texts, const Style& style, int icon

    else if (SHAPE == Shape::SQUARED) {
        n.surface->clear(style.bg_color);
-        SDL_FRect squared_rect = {.x = 0, .y = 0, .w = n.surface->getWidth(), .h = n.surface->getHeight()};
+        SDL_FRect squared_rect = {.x = 0, .y = 0, .w = static_cast<float>(n.surface->getWidth()), .h = static_cast<float>(n.surface->getHeight())};
        n.surface->drawRectBorder(&squared_rect, style.border_color);
    }

--- a/tools/pack_resources/Makefile
+++ b/tools/pack_resources/Makefile
@@ -1,53 +0,0 @@
-# Makefile for pack_resources tool
-
-# Compiler
-CXX := g++
-CXXFLAGS := -std=c++20 -Wall -Wextra -O2
-
-# Directories
-TOOL_DIR := .
-SOURCE_DIR := ../../source/core/resources
-
-# Source files
-SOURCES := pack_resources.cpp \
-           $(SOURCE_DIR)/resource_pack.cpp
-
-# Output
-TARGET := pack_resources
-
-# Platform-specific executable extension
-ifeq ($(OS),Windows_NT)
-    TARGET := $(TARGET).exe
-endif
-
-# Default target
-all: $(TARGET)
-
-# Build the tool
-$(TARGET): $(SOURCES)
-	@echo "Building pack_resources tool..."
-	$(CXX) $(CXXFLAGS) $(SOURCES) -o $(TARGET)
-	@echo "Build complete: $(TARGET)"
-
-# Test: create a test pack
-test: $(TARGET)
-	@echo "Creating test pack..."
-	./$(TARGET) ../../data test_resources.pack
-
-# Create the actual resources.pack
-pack: $(TARGET)
-	@echo "Creating resources.pack..."
-	./$(TARGET) ../../data ../../resources.pack
-
-# List contents of a pack
-list: $(TARGET)
-	@echo "Listing pack contents..."
-	./$(TARGET) --list ../../resources.pack
-
-# Clean
-clean:
-	@echo "Cleaning..."
-	rm -f $(TARGET) test_resources.pack
-	@echo "Clean complete"
-
-.PHONY: all test pack list clean
Author	SHA1	Message	Date
Sergio Valor	3e6fcfeb72	correccions en el makefile de macos	2026-05-03 18:03:30 +02:00
Sergio Valor	2474283e07	afegit suppress a cppcheck	2026-04-18 12:28:19 +02:00
Sergio Valor	d58c0303e9	surface: hallazgo 1 — SurfaceData::width/height de float a int Las dimensiones en píxeles son enteros por naturaleza. Convertidos los miembros y constructores a int, y ajustados getWidth()/getHeight() para devolver int. Eliminados los static_cast<int>(...->width/height) y static_cast<int>(surface->getWidth/getHeight()) redundantes que sólo existían para compensar el tipo erróneo. Los callers que inicializan SDL_FRect directamente con getWidth/getHeight requieren static_cast<float> explícito (sprite.cpp, animated_sprite.cpp, notifier.cpp, title.cpp) por las reglas de narrowing de list-init. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 12:22:19 +02:00
Sergio Valor	5f0b4355e4	surface: hallazgo 4 — elimina render(6 floats) sin callers La sobrecarga render(float dx, float dy, float sx, float sy, float w, float h) no tenía un solo caller en el proyecto. Las otras dos sobrecargas (con SDL_FRect) cubren todos los casos de uso reales. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 12:16:46 +02:00
Sergio Valor	40ac657f74	surface: hallazgo 8 — elimina setSurfaceData muerto y documenta shared_ptr setSurfaceData() no tenía callers. El shared_ptr<SurfaceData> se queda porque render() puede aliasar el SurfaceData propio con el del renderer surface (self-blit). Migrar a unique_ptr requeriría tocar Screen y dissolve_sprite sin simplificación real. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 12:01:51 +02:00
Sergio Valor	6a12294a36	surface: hallazgo 5 — renderWithColorReplace aplica sub_palette_ Coherencia con render() y renderWithVerticalFade(): el píxel no sustituido pasa por sub_palette_ en vez de copiarse crudo. Hoy es no-op (las surfaces que usan color replace no hacen fadeSubPalette) pero cierra la divergencia de API y previene regresiones futuras. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:58:46 +02:00
Sergio Valor	1f5b1ad1ab	surface: hallazgo 2 — drawLine con Bresenham en enteros El bucle usaba floats con comparación de igualdad exacta (x1==x2 && y1==y2) como condición de parada, con incrementos ±1.0f acumulados: bug latente. Convertidos los endpoints de entrada con std::lround y reescrito el algoritmo con ints. Firma pública float preservada para no tocar callers. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:55:12 +02:00
Sergio Valor	b1413bbf8a	surface: hallazgo 3 — sustituye sizeof check por static_assert en fade*Palette palette_ y sub_palette_ son std::array de tamaño fijo, así que el check en runtime nunca podía fallar. Movido a static_assert sobre tuple_size_v. El throw asociado era código muerto. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:54:33 +02:00
Sergio Valor	eaf9d87d6d	surface: hallazgo 6 — elimina doble std::min en render(int,int,...) Las dos líneas de clamp contra el destino estaban duplicadas. Fusionado el comentario y dejado un único bloque que limita contra origen y destino. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:53:59 +02:00
Sergio Valor	60adfc8fbb	surface: hallazgo 7 — elimina NOLINT obsoleto en loadSurface loadSurface es static en declaración y definición, así que el NOLINT(readability-convert-member-functions-to-static) era dead noise. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:53:33 +02:00
Sergio Valor	0dbf38f506	normalitzat Audio	2026-04-18 11:43:45 +02:00
Sergio Valor	53c2b345c9	build: unifica .clang-format/.clang-tidy i exclou external/ i spv/ amb dummies	2026-04-17 16:21:56 +02:00
Sergio Valor	74e19e9951	arreglos en make i cmake per estandaritzar amb la resta de projectes Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-17 13:00:02 +02:00
Sergio Valor	7480616c07	fix: android input amb sdl_joystick	2026-04-15 23:54:15 +02:00
Sergio Valor	6a76c65771	make controllerdb trim del nom del mando	2026-04-15 09:49:58 +02:00
Sergio Valor	9f22e1c58b	opcions per amagar la pantalla de carrega	2026-04-15 09:23:36 +02:00
Sergio Valor	727e55af03	arreglos en screen	2026-04-15 06:31:43 +02:00
Sergio Valor	6e0d9235a3	undo android test	2026-04-13 21:26:41 +02:00
Sergio Valor	98f251d155	android test	2026-04-13 21:17:31 +02:00