afegits estats a la clase Game

corregit Makefile

.clang-format

@@ -0,0 +1,21 @@
+BasedOnStyle: Google
+IndentWidth: 4
+IndentAccessModifiers: true
+ColumnLimit: 0  # Sin límite de longitud de línea
+BreakBeforeBraces: Attach  # Llaves en la misma línea
+AllowShortIfStatementsOnASingleLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AlignOperands: DontAlign
+AlignAfterOpenBracket: DontAlign
+BinPackArguments: false
+BinPackParameters: false
+ContinuationIndentWidth: 4
+ConstructorInitializerIndentWidth: 4
+IndentWrappedFunctionNames: false
+Cpp11BracedListStyle: true
+BreakConstructorInitializers: BeforeColon
+AllowAllConstructorInitializersOnNextLine: false
+PackConstructorInitializers: Never
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false

.clang-tidy

@@ -0,0 +1,85 @@
+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
+  - -readability-identifier-length
+  - -readability-magic-numbers
+  - -bugprone-narrowing-conversions
+  - -performance-enum-size
+  - -performance-inefficient-string-concatenation
+  - -bugprone-integer-division
+  - -bugprone-easily-swappable-parameters
+  - -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).*'
+FormatStyle: file
+
+CheckOptions:
+  # Variables locales en snake_case
+  - { key: readability-identifier-naming.VariableCase, value: lower_case }
+
+  # Miembros privados en snake_case con sufijo _
+  - { key: readability-identifier-naming.PrivateMemberCase, value: lower_case }
+  - { key: readability-identifier-naming.PrivateMemberSuffix, value: _ }
+
+  # Miembros protegidos en snake_case con sufijo _
+  - { key: readability-identifier-naming.ProtectedMemberCase, value: lower_case }
+  - { key: readability-identifier-naming.ProtectedMemberSuffix, value: _ }
+
+  # Miembros públicos en snake_case (sin sufijo)
+  - { key: readability-identifier-naming.PublicMemberCase, value: lower_case }
+
+  # Namespaces en CamelCase
+  - { key: readability-identifier-naming.NamespaceCase, value: CamelCase }
+
+  # Variables estáticas privadas como miembros privados
+  - { key: readability-identifier-naming.StaticVariableCase, value: lower_case }
+  - { key: readability-identifier-naming.StaticVariableSuffix, value: _ }
+  
+  # Constantes estáticas sin sufijo
+  - { key: readability-identifier-naming.StaticConstantCase, value: UPPER_CASE }
+
+  # Constantes globales en UPPER_CASE
+  - { key: readability-identifier-naming.GlobalConstantCase, value: UPPER_CASE }
+
+  # Variables constexpr globales en UPPER_CASE
+  - { key: readability-identifier-naming.ConstexprVariableCase, value: UPPER_CASE }
+
+  # Constantes locales en UPPER_CASE
+  - { key: readability-identifier-naming.LocalConstantCase, value: UPPER_CASE }
+
+  # Constexpr miembros en UPPER_CASE (sin sufijo)
+  - { key: readability-identifier-naming.ConstexprMemberCase, value: UPPER_CASE }
+
+  # Constexpr miembros privados/protegidos con sufijo _
+  - { key: readability-identifier-naming.ConstexprMethodCase, value: UPPER_CASE }
+
+  # Clases, structs y enums en CamelCase
+  - { key: readability-identifier-naming.ClassCase, value: CamelCase }
+  - { key: readability-identifier-naming.StructCase, value: CamelCase }
+  - { key: readability-identifier-naming.EnumCase, value: CamelCase }
+
+  # Valores de enums en UPPER_CASE
+  - { key: readability-identifier-naming.EnumConstantCase, value: UPPER_CASE }
+
+  # Métodos en camelBack (sin sufijos)
+  - { key: readability-identifier-naming.MethodCase, value: camelBack }
+  - { key: readability-identifier-naming.PrivateMethodCase, value: camelBack }
+  - { key: readability-identifier-naming.ProtectedMethodCase, value: camelBack }
+  - { key: readability-identifier-naming.PublicMethodCase, value: camelBack }
+
+  # Funciones en camelBack
+  - { key: readability-identifier-naming.FunctionCase, value: camelBack }
+
+  # Parámetros en lower_case
+  - { key: readability-identifier-naming.ParameterCase, value: lower_case }

.claude/commands/lint-clang-tidy.md

@@ -0,0 +1,172 @@
+---
+description: Ejecuta clang-tidy en archivos C++ y analiza los resultados
+---
+
+# Lint clang-tidy Command
+
+Ejecuta análisis estático con clang-tidy en archivos C++ específicos, analiza los resultados inteligentemente, e identifica issues reales vs falsos positivos.
+
+## Propósito
+
+clang-tidy detecta:
+- Oportunidades de modernización C++ (auto, range-for, etc.)
+- Problemas de legibilidad del código
+- Potenciales bugs y memory leaks
+- Optimizaciones de performance
+- Violaciones de mejores prácticas
+
+## Workflow de Ejecución
+
+1. **Solicitar archivos al usuario** (si no se especifican)
+   - Pedir rutas de archivos `.cpp` o `.hpp` a analizar
+   - Validar que los archivos existen
+
+2. **Verificar build directory**
+   - Confirmar que `build/compile_commands.json` existe
+   - Si no existe, informar al usuario que debe compilar primero
+
+3. **Ejecutar clang-tidy (sin --fix)**
+   ```bash
+   tools/linter/run_clang-tidy.sh archivo1.cpp archivo2.hpp
+   ```
+
+4. **Capturar y analizar salida**
+   - Parsear mensajes de error/warning
+   - Clasificar por categoría (modernize, readability, performance, bugprone, etc.)
+   - Identificar falsos positivos conocidos
+
+5. **Presentar resumen al usuario**
+   - Agrupar por tipo de issue
+   - Separar "Críticos" vs "Recomendaciones" vs "Falsos Positivos"
+   - Mostrar líneas de código afectadas con contexto
+
+6. **Ofrecer acciones**
+   - Preguntar si aplicar `--fix` automáticamente
+   - Si el usuario acepta, ejecutar con `--fix` y recompilar
+
+## Falsos Positivos Conocidos
+
+Ignorar o marcar como "Opcional" estos casos:
+
+### `readability-magic-numbers` / `cppcoreguidelines-avoid-magic-numbers`
+- **Contexto:** Game constants (block sizes, velocities, timers)
+- **Ejemplo:** `const int BLOCK = 16;`, `player.vx = 3.0F;`
+- **Acción:** Marcar como "Opcional - Game constant"
+
+### `modernize-use-trailing-return-type`
+- **Contexto:** Funciones con tipos de retorno simples
+- **Ejemplo:** `int getValue() { return x_; }`
+- **Acción:** Marcar como "Opcional - Style preference"
+
+### Errores en `defaults.hpp`
+- **Contexto:** Archivos de constantes del juego
+- **Acción:** Ignorar completamente, mencionar al usuario que es conocido
+
+### `readability-identifier-length`
+- **Contexto:** Variables cortas comunes en loops o coordenadas (`x`, `y`, `i`, `j`)
+- **Acción:** Marcar como "Opcional - Common convention"
+
+## Categorización de Issues
+
+### 🔴 Críticos (Requieren atención)
+- `bugprone-*`: Potenciales bugs
+- `cert-*`: Security issues
+- Memory leaks y null pointer dereferences
+- Undefined behavior
+
+### 🟡 Recomendados (Mejoran calidad)
+- `modernize-*`: C++20 modernization
+- `performance-*`: Optimizaciones
+- `readability-*`: Mejoras de legibilidad (excepto magic-numbers)
+
+### ⚪ Opcionales (A criterio)
+- `readability-magic-numbers` en game constants
+- `modernize-use-trailing-return-type`
+- `readability-identifier-length` para `x`, `y`, `i`, `j`
+
+### ⚫ Ignorar (Falsos positivos)
+- Errores en `defaults.hpp`
+- Issues en carpeta `external/`
+- Warnings en headers del sistema
+
+## Formato de Reporte al Usuario
+
+```
+=== clang-tidy Analysis Results ===
+
+📁 Archivos analizados:
+  - source/game/entities/player.cpp
+  - source/game/entities/player.hpp
+
+🔴 Críticos (2):
+  player.cpp:145 [bugprone-use-after-move] - Uso de variable después de std::move()
+  player.cpp:230 [cert-err58-cpp] - Excepción en inicialización estática
+
+🟡 Recomendados (5):
+  player.cpp:67 [modernize-use-auto] - Puede usar 'auto' en lugar de tipo explícito
+  player.cpp:102 [performance-unnecessary-copy-initialization] - Copia innecesaria
+  player.hpp:23 [readability-redundant-access-specifiers] - Especificador de acceso redundante
+
+⚪ Opcionales (3):
+  player.cpp:88 [readability-magic-numbers] - Magic number '16' (Game constant: BLOCK size)
+  player.cpp:120 [modernize-use-trailing-return-type] - Style preference
+
+✅ Total: 10 issues (2 críticos, 5 recomendados, 3 opcionales)
+
+---
+
+💡 Recomendaciones:
+1. Corregir los 2 issues críticos manualmente
+2. Aplicar --fix para 5 recomendaciones (revisa cambios antes de commitear)
+3. Los opcionales son aceptables en código de juego
+
+¿Deseas aplicar fixes automáticos para los issues recomendados? (y/n)
+```
+
+## Aplicar Fixes Automáticos
+
+Si el usuario acepta:
+
+1. **Ejecutar con --fix**
+   ```bash
+   tools/linter/run_clang-tidy.sh --fix archivo1.cpp archivo2.hpp
+   ```
+
+2. **Informar cambios**
+   - Listar archivos modificados
+   - Recomendar revisión manual
+
+3. **Recompilar**
+   ```bash
+   cmake --build build
+   ```
+
+4. **Verificar compilación exitosa**
+   - Si falla, informar errores
+   - Sugerir revertir cambios si es necesario
+
+## Notas Importantes
+
+- **Siempre analizar sin --fix primero** para revisar cambios propuestos
+- **Requiere build/compile_commands.json** - el usuario debe haber compilado antes
+- **Contexto importa** - Game code tiene patrones legítimos que linters marcan como issues
+- **No aplicar --fix ciegamente** - Algunos fixes pueden romper lógica del juego
+- **Archivos específicos** - Siempre analizar archivos concretos, no todo el proyecto
+
+## Integración con Otros Comandos
+
+Este comando puede ser llamado desde:
+- `/refactor-class` - Después de refactorizar una clase
+- Manualmente por el usuario para análisis ad-hoc
+- Antes de commits importantes
+
+---
+
+**Uso:**
+```
+/lint-clang-tidy
+(El comando preguntará qué archivos analizar)
+
+O especificar directamente:
+/lint-clang-tidy source/game/entities/player.cpp
+```

.claude/commands/lint-cppcheck.md

@@ -0,0 +1,275 @@
+---
+description: Ejecuta cppcheck en código C++ y analiza resultados
+---
+
+# Lint cppcheck Command
+
+Ejecuta análisis estático con cppcheck en código C++, filtra noise, e identifica issues reales relacionados con bugs, memory safety y undefined behavior.
+
+## Propósito
+
+cppcheck detecta:
+- Memory leaks y resource leaks
+- Null pointer dereferences
+- Buffer overflows y array bounds issues
+- Uninitialized variables
+- Dead code y unused functions
+- Style issues y code smells
+- Undefined behavior
+
+## Workflow de Ejecución
+
+1. **Solicitar archivos/rutas al usuario** (si no se especifican)
+   - Pedir rutas de archivos `.cpp`/`.hpp` o carpetas a analizar
+   - Preguntar nivel de análisis (warning/all/unused)
+   - Default: `-w` (warning, style, performance)
+
+2. **Validar precondiciones**
+   - Confirmar que los archivos/carpetas existen
+   - Si no existe `build/compile_commands.json`, el script lo generará automáticamente
+
+3. **Ejecutar cppcheck**
+   ```bash
+   # Para archivo específico
+   tools/linter/run_cppcheck.sh -w --path source/game/entities/player.cpp
+
+   # Para carpeta
+   tools/linter/run_cppcheck.sh -w --path source/game/entities/
+
+   # Proyecto completo (LENTO)
+   tools/linter/run_cppcheck.sh -w
+   ```
+
+4. **Leer archivo de resultados**
+   - `-w`: `tools/linter/cppcheck-result-warning-style-performance.txt`
+   - `-a`: `tools/linter/cppcheck-result-all.txt`
+   - `-u`: `tools/linter/cppcheck-result-unusedFunction.txt`
+
+5. **Analizar y clasificar issues**
+   - Parsear formato de cppcheck: `[archivo:línea]: (severidad) mensaje`
+   - Filtrar falsos positivos conocidos
+   - Agrupar por categoría
+
+6. **Presentar resumen al usuario**
+   - Mostrar issues críticos primero
+   - Explicar contexto cuando sea relevante
+   - Sugerir acciones correctivas
+
+## Niveles de Análisis
+
+### `-w` / `--warning` (Recomendado para uso diario)
+- **Velocidad:** Rápido
+- **Checks:** warning, style, performance
+- **Uso:** Refactoring diario, antes de commits
+- **Ejemplo:** `tools/linter/run_cppcheck.sh -w --path source/game/entities/player.cpp`
+
+### `-a` / `--all` (Análisis exhaustivo)
+- **Velocidad:** Lento
+- **Checks:** Todos los checks disponibles
+- **Uso:** Después de cambios mayores, auditorías de código
+- **Ejemplo:** `tools/linter/run_cppcheck.sh -a --path source/game/`
+
+### `-u` / `--unused` (Funciones no usadas)
+- **Velocidad:** Medio
+- **Checks:** unusedFunction
+- **Uso:** Limpieza de código muerto
+- **Ejemplo:** `tools/linter/run_cppcheck.sh -u`
+- **Nota:** Requiere análisis de proyecto completo
+
+## Falsos Positivos Conocidos
+
+### `unusedFunction` en métodos públicos
+- **Contexto:** Métodos de API pública, callbacks, getters/setters
+- **Ejemplo:** `Player::getX()` usado desde múltiples lugares
+- **Acción:** Ignorar si el método es parte de la interfaz pública
+
+### `passedByValue` para tipos pequeños
+- **Contexto:** SDL_FRect, SDL_Point, enums, small structs
+- **Ejemplo:** `void setPos(SDL_FPoint pos)`
+- **Acción:** Aceptable para tipos ≤ 16 bytes en game code
+
+### `constParameter` en APIs consistentes
+- **Contexto:** Parámetros que no se modifican pero mantienen consistencia de API
+- **Acción:** Opcional, depende de estilo del proyecto
+
+### `variableScope` en inicializaciones complejas
+- **Contexto:** Variables declaradas antes de inicialización compleja
+- **Acción:** Revisar caso por caso, puede ser falso positivo
+
+## Categorización de Issues
+
+### 🔴 Críticos (Requieren corrección inmediata)
+- `error`: Bugs confirmados
+- `memleakOnRealloc`: Memory leaks
+- `nullPointer`: Null pointer dereferences
+- `bufferAccessOutOfBounds`: Buffer overflows
+- `uninitvar`: Variables no inicializadas
+- `useAfterFree`: Use-after-free
+
+### 🟠 Advertencias (Revisar y corregir)
+- `warning`: Potenciales problemas
+- `memleak`: Posibles memory leaks
+- `resourceLeak`: Resource leaks (file handles, etc.)
+- `doubleFree`: Double free
+- `arrayIndexOutOfBounds`: Array bounds issues
+
+### 🟡 Estilo (Mejoran calidad)
+- `style`: Code smells
+- `unusedVariable`: Variables no usadas
+- `redundantAssignment`: Asignaciones redundantes
+- `unreadVariable`: Variables escritas pero no leídas
+
+### 🟢 Performance (Optimizaciones)
+- `performance`: Optimizaciones de rendimiento
+- `passedByValue`: Pasar por const& en vez de value
+- `postfixOperator`: Usar prefix++ en vez de postfix++
+
+### ⚪ Informativo (Opcional)
+- `information`: Información general
+- `portability`: Problemas de portabilidad
+- `unusedFunction`: Funciones no usadas (revisar contexto)
+
+## Formato de Reporte al Usuario
+
+```
+=== cppcheck Analysis Results ===
+
+📁 Archivos analizados: source/game/entities/player.cpp
+📊 Nivel: warning + style + performance
+📝 Resultados: tools/linter/cppcheck-result-warning-style-performance.txt
+
+🔴 Errores críticos (2):
+  player.cpp:156 [error:uninitvar] - Variable 'velocity' no inicializada
+  player.cpp:234 [error:nullPointer] - Posible null pointer dereference
+
+🟠 Advertencias (3):
+  player.cpp:89 [warning:memleak] - Posible memory leak en 'sprite_'
+  player.cpp:178 [warning:arrayIndexOutOfBounds] - Índice fuera de límites
+
+🟡 Estilo (4):
+  player.cpp:45 [style:unusedVariable] - Variable 'temp' declarada pero no usada
+  player.cpp:102 [style:redundantAssignment] - Asignación redundante a 'x_'
+
+🟢 Performance (2):
+  player.cpp:67 [performance:passedByValue] - Pasar 'data' por const& (8 bytes - FALSO POSITIVO)
+  player.hpp:34 [performance:postfixOperator] - Usar prefix++ en lugar de postfix++
+
+✅ Total: 11 issues
+   - 2 críticos ❗
+   - 3 advertencias
+   - 4 estilo
+   - 2 performance (1 falso positivo)
+
+---
+
+💡 Acción requerida:
+1. ✅ Corregir 2 errores críticos INMEDIATAMENTE
+2. ⚠️  Revisar 3 advertencias y corregir si aplica
+3. 🔧 Considerar 4 mejoras de estilo
+4. ⚡ 1 optimización real de performance (ignorar passedByValue)
+
+📄 Detalles completos en: tools/linter/cppcheck-result-warning-style-performance.txt
+```
+
+## Acciones Post-Análisis
+
+### Si hay errores críticos:
+1. **Mostrar código afectado** con contexto
+2. **Explicar el problema** en términos claros
+3. **Sugerir corrección** específica
+4. **Ofrecer aplicar fix** si es sencillo
+
+### Si solo hay warnings/style:
+1. **Resumir issues** por categoría
+2. **Indicar prioridades** (qué corregir primero)
+3. **Explicar falsos positivos** identificados
+4. **Preguntar si aplicar fixes** para issues simples
+
+### Si no hay issues:
+```
+✅ ¡Código limpio! No se encontraron issues.
+```
+
+## Ejemplos de Correcciones Comunes
+
+### Uninitialized variable
+```cpp
+// ❌ Antes
+int velocity;
+if (condition) {
+    velocity = 10;
+}
+use(velocity);  // Error: puede estar no inicializada
+
+// ✅ Después
+int velocity{0};  // Inicializar en declaración
+if (condition) {
+    velocity = 10;
+}
+use(velocity);
+```
+
+### Memory leak
+```cpp
+// ❌ Antes
+void loadTexture() {
+    texture_ = new SDL_Texture(...);
+    if (error) return;  // Leak si hay error después
+}
+
+// ✅ Después
+void loadTexture() {
+    auto temp = std::make_unique<SDL_Texture>(...)
+    if (error) return;  // RAII - se libera automáticamente
+    texture_ = std::move(temp);
+}
+```
+
+### Null pointer dereference
+```cpp
+// ❌ Antes
+Player* player = getPlayer();
+player->update();  // Puede ser nullptr
+
+// ✅ Después
+Player* player = getPlayer();
+if (player != nullptr) {
+    player->update();
+}
+```
+
+## Integración con Workflow
+
+### Cuándo ejecutar:
+
+1. **Después de refactoring** - Verificar que no se introdujeron bugs
+2. **Antes de commit** - Análisis `-w` rápido
+3. **Antes de PR** - Análisis `-a` completo
+4. **Periódicamente** - Análisis `-u` para limpieza de código
+
+### Integración con `/refactor-class`:
+
+El comando `/refactor-class` ejecuta automáticamente:
+```bash
+tools/linter/run_cppcheck.sh -w --path <archivo_refactorizado>
+```
+
+## Notas Importantes
+
+- **Genera archivos de salida** en `tools/linter/cppcheck-result-*.txt`
+- **Auto-genera compile_commands.json** si no existe
+- **Paralelización automática** usa N-1 cores
+- **Suppressions file** excluye external/ y system headers
+- **Contexto importa** - Revisar falsos positivos manualmente
+- **No modifica código** - Solo reporta, no aplica fixes automáticos
+
+---
+
+**Uso:**
+```
+/lint-cppcheck
+(El comando preguntará qué analizar y qué nivel usar)
+
+O especificar directamente:
+/lint-cppcheck source/game/entities/player.cpp
+```

.claude/commands/refactor-class.md

@@ -0,0 +1,279 @@
+---
+description: Refactoriza una clase C++ aplicando buenas prácticas de estilo
+---
+
+# Refactor Class Command
+
+Refactoriza una clase C++ siguiendo estas reglas de estilo y buenas prácticas:
+
+## Reglas de Refactorización
+
+### 1. Inicialización de Variables Miembro
+- **Inicializar en la declaración** todas las variables "simples" que no tengan dependencias complejas:
+  - Tipos primitivos: `int`, `float`, `bool`, etc.
+  - Enumeraciones: valores de enum class
+  - Valores por defecto conocidos: `0`, `0.0F`, `false`, `nullptr`, etc.
+- **NO inicializar en declaración** si:
+  - Dependen de otros miembros
+  - Requieren llamadas a funciones complejas
+  - Son punteros a recursos que necesitan construcción específica
+
+### 2. Structs con Valores por Defecto
+- **Todos los miembros de structs** deben tener valores por defecto:
+  - Tipos primitivos: `int x{0}`, `float y{0.0F}`, `bool flag{false}`
+  - Strings: `std::string name{}`
+  - Punteros: `Type* ptr{nullptr}`
+- **Ventajas**: Inicialización segura, evita valores indefinidos
+
+### 3. Arrays C-style → std::array
+- Convertir **todos** los arrays C-style a `std::array`:
+  - `Type array[N]` → `std::array<Type, N> array{}`
+  - Inicializar con `{}` para zero-initialization
+- Agregar `#include <array>` si no existe
+- **Ventajas**: type-safety, size(), métodos STL, sin decay a pointer
+
+### 3. Reorganización de la Clase
+
+#### Orden de Secciones
+1. **public** (primero)
+2. **private** (después)
+
+#### Dentro de cada sección (private principalmente)
+1. **Estructuras y enumeraciones** (tipos anidados)
+2. **Constantes** (static constexpr)
+3. **Métodos** (funciones miembro)
+4. **Variables miembro** (al final)
+
+### 4. Agrupación y Comentarios de Métodos
+- **En sección public**: Agrupar métodos relacionados funcionalmente
+- **Comentarios en línea** (a la derecha) para describir cada método/grupo
+- **Formato**: `void method();  // Descripción concisa`
+- **Espaciado**: Línea en blanco entre grupos funcionales
+
+**Ejemplo:**
+```cpp
+public:
+    static void init(...);    // Inicialización singleton
+    static void destroy();    // Destrucción singleton
+    static auto get() -> T*;  // Acceso al singleton
+
+    void render();            // Renderizado
+    void update(float dt);    // Actualización lógica
+
+    auto isActive() -> bool;  // Consulta estado
+```
+
+### 5. Comentarios de Variables
+- **Posición**: A la derecha de la variable/grupo
+- **Formato**: `// Descripción concisa`
+- Agrupar variables relacionadas con un comentario común
+
+### 6. Constructores en Structs
+- **Eliminar constructores por defecto redundantes** en structs:
+  - Si todos los miembros tienen inicialización en declaración
+  - Y no hay múltiples constructores
+  - Eliminar `explicit Type() = default;`
+- El compilador generará automáticamente un constructor por defecto
+
+**Ejemplo:**
+```cpp
+struct Data {
+    int x{0};
+    std::string name{};
+    // NO NECESITA: explicit Data() = default;
+};
+```
+
+### 7. Includes Necesarios
+- Agregar includes faltantes según lo que se use
+- Mantener orden alfabético si es posible
+
+### 8. Header Guards
+- **Usar `#pragma once`** en todas las cabeceras (`.hpp`)
+- **NO usar** `#ifndef`/`#define`/`#endif` tradicionales
+- `#pragma once` debe ser la primera línea del archivo (antes de includes)
+- **Ventajas**: Más simple, menos propenso a errores, ampliamente soportado
+
+## Ejemplo de Aplicación
+
+### Antes:
+```cpp
+class Example {
+    private:
+        struct Data {
+            std::string name;
+            int value;
+        };
+
+        int counter_;
+        bool flag_;
+        float values_[10];
+
+    public:
+        Example();
+        void update();
+};
+
+// Constructor
+Example::Example()
+    : counter_(0),
+      flag_(false) {
+    for (int i = 0; i < 10; ++i) {
+        values_[i] = 0.0F;
+    }
+}
+```
+
+### Después:
+```cpp
+#pragma once
+
+#include <array>
+
+class Example {
+    public:
+        Example() = default;  // Ya no necesita inicializar
+        void update();
+
+    private:
+        // Tipos anidados
+        struct Data {
+            std::string name{};    // Nombre con valor por defecto
+            int value{0};          // Valor inicializado
+        };
+
+        // Variables miembro
+        int counter_{0};                        // Contador de frames
+        bool flag_{false};                      // Estado activo
+        std::array<float, 10> values_{};        // Buffer de valores
+};
+```
+
+## Tareas a Realizar
+
+Cuando uses este comando en una clase específica:
+
+1. **Leer** el archivo `.hpp` y `.cpp` correspondiente
+2. **Verificar** que la cabecera use `#pragma once` (reemplazar `#ifndef`/`#define`/`#endif` si existen)
+3. **Identificar** structs y agregar valores por defecto a todos sus miembros
+4. **Identificar** variables que pueden inicializarse en declaración
+5. **Identificar** arrays C-style que convertir a std::array
+6. **Reorganizar** la estructura de la clase (public/private, agrupación)
+7. **Actualizar** el archivo `.cpp` eliminando inicializaciones redundantes
+8. **Compilar** para verificar sintaxis correcta
+9. **Ejecutar clang-tidy** (análisis, sin --fix) y revisar resultados
+10. **Ejecutar cppcheck** (nivel -w) y revisar resultados
+11. **Aplicar fixes apropiados** basados en análisis de linters
+12. **Recompilar** si se aplicaron fixes
+13. **Reportar resumen** al usuario: cambios + hallazgos de linters
+
+## Workflow de Linters (Pasos 9-12)
+
+### Paso 9: Ejecutar clang-tidy
+
+```bash
+tools/linter/run_clang-tidy.sh archivo.cpp archivo.hpp
+```
+
+**Analizar resultados:**
+- Identificar issues críticos (bugprone, cert)
+- Separar recomendaciones válidas de falsos positivos
+- Ignorar: magic-numbers en game constants, defaults.hpp errors
+- Si hay issues críticos, informar al usuario y pausar
+- Si solo hay recomendaciones, continuar
+
+### Paso 10: Ejecutar cppcheck
+
+```bash
+tools/linter/run_cppcheck.sh -w --path archivo.cpp
+```
+
+**Leer archivo de resultados:**
+- `tools/linter/cppcheck-result-warning-style-performance.txt`
+- Identificar errores críticos (error, nullPointer, uninitvar)
+- Separar warnings de style issues
+- Filtrar falsos positivos (passedByValue para tipos pequeños, unusedFunction en API pública)
+- Si hay errores críticos, informar al usuario y pausar
+
+### Paso 11: Aplicar Fixes
+
+**Si hay issues aplicables:**
+
+1. **Fixes automáticos de clang-tidy** (solo si son seguros):
+   - modernize-use-auto
+   - readability-redundant-access-specifiers
+   - Performance optimizations claras
+
+   ```bash
+   tools/linter/run_clang-tidy.sh --fix archivo.cpp archivo.hpp
+   ```
+
+2. **Fixes manuales necesarios:**
+   - Inicializar variables no inicializadas
+   - Corregir null pointer issues
+   - Resolver memory leaks
+
+3. **Documentar cambios** para el reporte final
+
+### Paso 12: Recompilar
+
+Si se aplicaron fixes en paso 11:
+
+```bash
+cmake --build build
+```
+
+**Verificar:**
+- ✅ Compilación exitosa → Continuar a reporte
+- ❌ Errores → Informar al usuario, sugerir revisión manual
+
+## Formato de Reporte Final (Paso 13)
+
+```
+=== Refactor Completado: ClassName ===
+
+📝 Cambios estructurales:
+  ✅ #pragma once aplicado
+  ✅ 3 structs actualizados con valores por defecto
+  ✅ 12 variables movidas a inicialización en declaración
+  ✅ 2 arrays C-style → std::array
+  ✅ Clase reorganizada (public primero, variables al final)
+  ✅ Constructor simplificado (elimina 12 inicializaciones redundantes)
+
+🔍 Análisis de linters:
+
+clang-tidy:
+  ✅ Sin issues críticos
+  🟡 3 recomendaciones aplicadas automáticamente:
+     - Modernize: use auto (2 lugares)
+     - Readability: redundant specifier (1 lugar)
+  ⚪ 2 opcionales ignorados:
+     - magic-numbers en game constants
+
+cppcheck:
+  ✅ Sin errores
+  🟡 2 style issues encontrados:
+     - Unused variable 'temp' en línea 45 → Eliminada
+     - Redundant assignment en línea 102 → Corregida
+
+📊 Resultado:
+  ✅ Compilación exitosa
+  ✅ Todos los linters pasan sin issues críticos
+  ✅ Código refactorizado y verificado
+
+💡 Próximos pasos:
+  - Revisar cambios manualmente
+  - Ejecutar tests si existen
+  - Commitear con mensaje descriptivo
+```
+
+## Notas Importantes
+
+- **No cambiar lógica**: Solo refactorización estructural
+- **Mantener compatibilidad**: std::array usa misma sintaxis [] para acceso
+- **Formato consistente**: Respetar estilo del proyecto (comentarios, espaciado)
+- **Validar compilación**: Siempre verificar que compile después de cambios
+- **Linters integrados**: Análisis automático post-refactor para garantizar calidad
+- **Fixes inteligentes**: Solo aplicar --fix de clang-tidy si los cambios son seguros
+- **Contexto importa**: Game code tiene patrones legítimos (magic numbers, etc.)
+- **Falsos positivos**: Identificar y documentar, no corregir ciegamente

.claude/settings.local.json

@@ -0,0 +1,21 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(clang-tidy:*)",
+      "Bash(cat:*)",
+      "Bash(tools/linter/run_cppcheck.sh:*)",
+      "Bash(cmake --build:*)",
+      "Bash(tee:*)",
+      "Bash(tools/linter/run_clang-tidy.sh:*)",
+      "Bash(find:*)",
+      "Bash(for file in source/game/scenes/title.cpp source/game/scenes/game.cpp source/game/entities/player.cpp source/game/options.cpp source/core/rendering/screen.cpp)",
+      "Bash(do echo \"=== $file ===\")",
+      "Bash(done)",
+      "Bash(Xvfb:*)",
+      "Bash(chmod:*)",
+      "Bash(timeout:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

.gitignore

@@ -1,5 +1,5 @@
-.vscode
-*data/config/config.txt
+.vscode/
+*data/config/config.yaml
 *stats.txt
 *.DS_Store
 thumbs.db
@@ -11,8 +11,12 @@ thumbs.db
 *.zip
 *.app
 *_debug*
-sync_jail_engine.sh
 jaildoctors_dilemma*
 todo
 build/
-linux_utils/
+linux_utils/
+source/version.h
+resources.pack
+jdd_release/
+tools/pack_resources/pack_resources
+tools/pack_resources/pack_resources.exe

CLAUDE.md

@@ -0,0 +1,990 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+---
+
+# JailDoctor's Dilemma - Codebase Architecture Guide
+
+## Overview
+
+**JailDoctor's Dilemma** is a retro-style 2D puzzle platformer game built in C++20 using SDL3 for graphics and audio. The game features 60+ rooms, collectible items, enemies, and an achievement system. It targets multiple platforms (Windows, macOS, Linux) with a focus on retro aesthetics and precise collision detection.
+
+**Language:** C++20
+**Graphics:** SDL3, OpenGL
+**Audio:** SDL3 + custom jail_audio library
+**Build:** CMake 3.10+
+**Game Canvas:** 256x192 pixels (retro resolution)
+
+---
+
+## Build Commands
+
+### Initial Setup & Build
+```bash
+# From project root
+mkdir -p build
+cd build
+cmake ..
+cmake --build .
+```
+
+### Rebuild After Changes
+```bash
+# From build directory
+cmake --build .
+
+# Or from project root
+cmake --build build
+```
+
+### Clean Build
+```bash
+# From build directory
+cmake --build . --clean-first
+
+# Or from project root
+cmake --build build --clean-first
+```
+
+### Run the Game
+```bash
+# Executable is placed in project root
+./jaildoctors_dilemma
+```
+
+**Important:** The build directory is `/Users/sergio/Gitea/jaildoctors_dilemma/build` and the output executable is placed in the project root directory.
+
+### Testing in Headless Environment (SSH/Remote Server)
+
+**IMPORTANT:** When working on a remote server via SSH without a physical display, the game MUST be run using Xvfb (X Virtual Framebuffer) to avoid SDL3 display initialization errors.
+
+#### Required Setup (One-time)
+```bash
+# Install Xvfb
+sudo apt-get install xvfb
+```
+
+#### Running the Game in Headless Mode
+
+**Option 1: Using the wrapper script (RECOMMENDED)**
+```bash
+./run_headless.sh
+```
+
+**Option 2: Using xvfb-run directly**
+```bash
+xvfb-run -a ./jaildoctors_dilemma
+```
+
+**Option 3: Custom display configuration**
+```bash
+xvfb-run -a -s "-screen 0 1280x720x24" ./jaildoctors_dilemma
+```
+
+#### Why This Is Critical
+
+- **SDL3 requires a display:** The game uses SDL3 which requires X11/Wayland display
+- **No code changes needed:** Xvfb simulates a virtual display without modifying the codebase
+- **Full logging:** Console output and logs work normally, essential for debugging resource loading
+- **Testing resource loading:** When modifying asset loading code, running with xvfb-run allows seeing all initialization logs
+
+**ALWAYS use xvfb-run when testing on the remote server, especially when:**
+- Modifying resource loading code
+- Testing asset initialization
+- Debugging startup issues
+- Verifying configuration changes
+
+### Static Analysis Tools (Linters)
+
+This project uses two complementary static analysis tools for code quality:
+
+#### clang-tidy (Modernization & Best Practices)
+
+**Purpose:** Detects style issues, modernization opportunities, and potential bugs. Best for refactoring and applying C++20 best practices.
+
+**IMPORTANT:** Always run on specific files, NOT on the entire project, to avoid long execution times and errors in unrelated files.
+
+```bash
+# Analyze a specific file (RECOMMENDED)
+tools/linter/run_clang-tidy.sh source/game/entities/player.cpp
+
+# Analyze multiple specific files
+tools/linter/run_clang-tidy.sh source/game/entities/player.cpp source/game/entities/enemy.cpp
+
+# Apply fixes automatically to a specific file
+tools/linter/run_clang-tidy.sh --fix source/game/entities/player.cpp
+
+# Analyze entire project (SLOW, may have errors in defaults.hpp)
+tools/linter/run_clang-tidy.sh
+```
+
+**Common clang-tidy Checks:**
+- `modernize-*`: C++ modernization (use auto, range-for, etc.)
+- `readability-*`: Code readability improvements
+- `performance-*`: Performance optimizations
+- `bugprone-*`: Potential bug detection
+
+**Known False Positives:**
+- `defaults.hpp`: May report errors in constant definitions
+- `readability-magic-numbers`: Acceptable for game constants (block sizes, speeds, etc.)
+- `cppcoreguidelines-avoid-magic-numbers`: Same as above, acceptable in game code
+
+#### cppcheck (Bug Detection & Memory Safety)
+
+**Purpose:** Detects bugs, memory leaks, undefined behavior, and style issues. Complementary to clang-tidy.
+
+```bash
+# Warning, style, and performance analysis (RECOMMENDED for daily use)
+tools/linter/run_cppcheck.sh -w --path source/game/entities/player.cpp
+
+# Exhaustive analysis (slower, more thorough)
+tools/linter/run_cppcheck.sh -a --path source/game/entities/
+
+# Detect unused functions (whole project analysis)
+tools/linter/run_cppcheck.sh -u
+
+# Analyze entire project with warning level
+tools/linter/run_cppcheck.sh -w
+```
+
+**Output:** Results are saved in `tools/linter/cppcheck-result-*.txt`
+
+**Common cppcheck Checks:**
+- Memory leaks and resource management
+- Null pointer dereferences
+- Buffer overflows and array bounds
+- Uninitialized variables
+- Dead code and unused functions
+
+**Known False Positives:**
+- `unusedFunction`: May report false positives for callback functions or public API methods
+- `passedByValue`: Acceptable for small types like SDL_FRect in game code
+- `constParameter`: Not always applicable for API consistency
+
+#### When to Use Each Tool
+
+| Scenario | Tool | Reason |
+|----------|------|--------|
+| **Daily refactoring** | clang-tidy | Fast, auto-fixable issues |
+| **Before committing** | Both | Comprehensive quality check |
+| **After major changes** | cppcheck -a | Deep bug analysis |
+| **Hunting memory leaks** | cppcheck | Specialized detection |
+| **Code modernization** | clang-tidy --fix | Automatic C++20 upgrades |
+
+#### Best Practices
+
+1. **Run linters after compilation succeeds** - Fix compile errors first
+2. **Analyze specific files** - Faster feedback, avoids unrelated errors
+3. **Review before applying --fix** - Understand changes before accepting
+4. **Context matters** - Game code may legitimately have "magic numbers" for gameplay constants
+5. **Use both tools** - They catch different issues and complement each other
+6. **Check suppressions file** - `tools/linter/cppcheck_suppressions` excludes external/ and system headers
+
+#### Integration with Development Workflow
+
+When refactoring code (especially with `/refactor-class` command):
+1. Make structural changes
+2. **Compile** to verify syntax
+3. **Run clang-tidy** (without --fix) to identify issues
+4. **Run cppcheck -w** to catch bugs
+5. Review and fix legitimate issues
+6. Apply automatic fixes if appropriate
+7. Recompile and test
+
+**Note:** The `/refactor-class` command automatically runs both linters after compilation and provides intelligent analysis of results.
+
+---
+
+## 1. High-Level Architecture Overview
+
+The architecture follows a **layered, modular design** with clear separation of concerns:
+
+```
+┌─────────────────────────────────────┐
+│        Application Layer             │
+│  (Director, Scene Manager)           │
+└─────────────────────────────────────┘
+                  ↓
+┌─────────────────────────────────────┐
+│        Game Logic Layer              │
+│  (Game Scene, Entities, Gameplay)    │
+└─────────────────────────────────────┘
+                  ↓
+┌─────────────────────────────────────┐
+│        Core Systems Layer            │
+│  (Rendering, Audio, Input, Resources)│
+└─────────────────────────────────────┘
+                  ↓
+┌─────────────────────────────────────┐
+│     SDL3 & External Libraries        │
+│  (jail_audio, stb_image, stb_vorbis) │
+└─────────────────────────────────────┘
+```
+
+### Key Design Principles
+
+- **Singleton Pattern:** Core systems (Director, Screen, Audio, Input, Resource, Asset) use singleton pattern for global access
+- **Scene-Based Architecture:** Game flow managed through discrete scenes (Logo, Title, Loading, Game, Ending, etc.)
+- **Component-Based Entities:** Player, enemies, and items are discrete entities with render/update patterns
+- **Resource Management:** All assets (textures, sounds, animations, tilemaps) cached through Resource singleton
+- **Delta Time:** Frame-rate independent physics using DeltaTimer class
+
+---
+
+## 2. Directory Structure
+
+```
+source/
+├── core/                          # Core engine systems
+│   ├── audio/                     # Audio management
+│   │   └── audio.hpp/cpp          # Audio singleton (music, sounds, volumes)
+│   ├── input/                     # Input handling
+│   │   ├── input.hpp/cpp          # Input manager (keyboard, gamepad)
+│   │   ├── global_inputs.hpp      # Global input state
+│   │   └── mouse.hpp              # Mouse input
+│   ├── rendering/                 # Graphics rendering
+│   │   ├── screen.hpp/cpp         # Screen/window singleton, SDL renderer
+│   │   ├── surface.hpp/cpp        # 8-bit indexed color surface abstraction
+│   │   ├── surface_sprite.hpp     # Static sprite rendering
+│   │   ├── surface_animated_sprite.hpp # Animated sprite with frame data
+│   │   ├── surface_moving_sprite.hpp   # Moving sprite with velocity
+│   │   ├── texture.hpp/cpp        # SDL texture wrapper
+│   │   ├── text.hpp/cpp           # Text rendering system
+│   │   ├── gif.hpp/cpp            # GIF image loader
+│   │   ├── opengl/                # OpenGL shader backend
+│   │   │   └── opengl_shader.hpp/cpp  # CRT shader effects
+│   │   └── shader_backend.hpp     # Abstract shader interface
+│   ├── resources/                 # Asset & Resource management
+│   │   ├── asset.hpp/cpp          # Asset registry (file path mapping)
+│   │   └── resource.hpp/cpp       # Resource singleton (loads/caches assets)
+│   └── system/                    # System management
+│       ├── director.hpp/cpp       # Main application controller
+│       ├── debug.hpp/cpp          # Debug info overlay
+│       └── global_events.hpp/cpp  # Global event broadcasting
+├── game/                          # Game-specific logic
+│   ├── entities/                  # Game objects
+│   │   ├── player.hpp/cpp         # Player entity with physics
+│   │   ├── enemy.hpp/cpp          # Enemy entities
+│   │   └── item.hpp/cpp           # Collectible items
+│   ├── gameplay/                  # Core gameplay systems
+│   │   ├── room.hpp/cpp           # Room/level logic, tilemap, collision
+│   │   ├── room_tracker.hpp/cpp   # Tracks visited rooms
+│   │   ├── scoreboard.hpp/cpp     # Score display & data
+│   │   ├── item_tracker.hpp/cpp   # Tracks collected items
+│   │   ├── stats.hpp/cpp          # Game statistics
+│   │   └── cheevos.hpp/cpp        # Achievement system
+│   ├── scenes/                    # Game scenes (flow states)
+│   │   ├── logo.hpp/cpp           # JailGames logo screen
+│   │   ├── loading_screen.hpp/cpp # Resource loading progress
+│   │   ├── title.hpp/cpp          # Title screen & menus
+│   │   ├── game.hpp/cpp           # Main gameplay loop
+│   │   ├── game_over.hpp/cpp      # Game over screen
+│   │   ├── ending.hpp/cpp         # Ending sequence 1
+│   │   ├── ending2.hpp/cpp        # Ending sequence 2
+│   │   └── credits.hpp/cpp        # Credits screen
+│   ├── ui/                        # User interface
+│   │   └── notifier.hpp/cpp       # Achievement/notification display
+│   ├── options.hpp/cpp            # Game configuration/options
+│   ├── scene_manager.hpp          # Scene flow state machine
+│   ├── defaults.hpp               # Game defaults constants
+│   └── gameplay.hpp               # Gameplay constants
+├── external/                      # Third-party libraries
+│   ├── jail_audio.hpp/cpp         # Custom audio library
+│   ├── jail_audio.h               # C interface for jail_audio
+│   ├── stb_image.h                # Image loading library
+│   └── stb_vorbis.h               # OGG Vorbis audio decoding
+├── utils/                         # Utility code
+│   ├── delta_timer.hpp/cpp        # Frame-rate independent timing
+│   ├── defines.hpp                # Game constants (resolutions, block sizes)
+│   └── utils.hpp/cpp              # Helper functions (colors, math)
+└── main.cpp                       # Application entry point
+
+config/                            # Configuration files
+└── assets.yaml                     # Asset registry (text-based configuration)
+
+data/                              # Game assets
+├── font/                          # Bitmap fonts + descriptors
+├── palette/                       # Color palettes (.pal files)
+├── shaders/                       # GLSL vertex/fragment shaders
+├── room/                          # Tilemaps & room definitions (01.tmx-60.tmx)
+├── tilesets/                      # Tileset graphics
+├── enemies/                       # Enemy sprites & animations
+├── player/                        # Player sprites & animations
+├── items/                         # Item sprite sheets
+├── music/                         # Background music (OGG)
+├── sound/                         # Sound effects (WAV)
+├── logo/                          # Logo images
+├── loading/                       # Loading screen graphics
+├── title/                         # Title screen graphics
+├── ending/                        # Ending sequence images
+└── credits/                       # Credits screen assets
+```
+
+---
+
+## 3. Key Architectural Patterns
+
+### 3.1 Singleton Pattern (Core Systems)
+
+Most core systems use thread-safe singleton pattern:
+
+```cpp
+class Screen {
+    private:
+        static Screen* screen_;  // Singleton instance
+        Screen();                // Private constructor
+        ~Screen();
+    public:
+        static void init();      // Creates singleton
+        static void destroy();   // Destroys singleton
+        static Screen* get();    // Accesses singleton
+};
+```
+
+**Singleton Systems:**
+- `Screen` - Rendering, window management, palette/shader effects
+- `Input` - Keyboard & gamepad input binding and checking
+- `Audio` - Music and sound effect playback
+- `Resource::Cache` - Asset loading, caching, streaming (with error handling)
+- `Resource::List` - Asset path registry from assets.yaml (O(1) lookups)
+- `Director` - Main application controller
+- `Cheevos` - Achievement state management
+- `Debug` - Debug information overlay
+
+### 3.2 Scene-Based State Machine
+
+The game uses a scene manager to control application flow:
+
+```cpp
+// namespace SceneManager
+enum class Scene {
+    LOGO, LOADING_SCREEN, TITLE, CREDITS, GAME, DEMO, 
+    GAME_OVER, ENDING, ENDING2, QUIT
+};
+
+inline Scene current = Scene::LOGO;  // Global scene state
+inline Options options = ...;        // Transition options
+```
+
+**Scene Hierarchy:**
+- Each scene runs its own update/render loop
+- `Director` switches between scenes based on `SceneManager::current`
+- Scenes can request transitions via `SceneManager::current` assignment
+
+### 3.3 Entity-Component Pattern (Simplified)
+
+Entities (Player, Enemies, Items) have:
+- **Update** - Logic, physics, animation
+- **Render** - Draw to screen surface
+- **Collision** - Hit detection (player collides with room, enemies, items)
+
+### 3.4 Surface-Based Rendering Pipeline
+
+The rendering system uses a **8-bit indexed color** pipeline:
+
+```
+SurfaceData (pixel buffer)
+     ↓
+Surface (palette + rendering operations)
+     ↓
+SDL_Texture (GPU texture)
+     ↓
+SDL_Renderer (to SDL_Window)
+     ↓
+Display
+```
+
+**Key Components:**
+- `Surface` - 8-bit indexed pixel buffer with palette support
+- `SurfaceSprite` - Renders a fixed region of a surface
+- `SurfaceAnimatedSprite` - Frame-based animation on top of sprite
+- `SurfaceMovingSprite` - Adds velocity/position to animated sprite
+- Supports color replacement, palette swapping, and shader effects (CRT)
+
+### 3.5 Tile-Based Collision System
+
+Rooms use a sophisticated collision detection system:
+
+```cpp
+class Room {
+    std::vector<LineHorizontal> bottom_floors_;   // Ground surfaces
+    std::vector<LineHorizontal> top_floors_;      // Ceiling surfaces
+    std::vector<LineVertical> left_walls_;        // Left walls
+    std::vector<LineVertical> right_walls_;       // Right walls
+    std::vector<LineDiagonal> left_slopes_;       // Ramps going left
+    std::vector<LineDiagonal> right_slopes_;      // Ramps going right
+    std::vector<LineHorizontal> conveyor_belt_floors_; // Moving platforms
+};
+```
+
+**Collision Detection:**
+- Player has collision points and "feet" points for fine-grained detection
+- Room provides `check*Surfaces()` methods for collision resolution
+- Supports ramps, slopes, conveyor belts, and auto-surfaces
+- Enemies have axis-aligned bounding boxes
+
+### 3.6 Sprite Animation System
+
+Animation is data-driven:
+
+```cpp
+struct AnimationData {
+    std::string name;
+    std::vector<SDL_FRect> frames;  // Frame rectangles
+    int speed;                       // Milliseconds per frame
+    int loop;                        // Frame to return to (-1 = no loop)
+    bool completed;
+    int current_frame;
+    int counter;
+};
+
+// Loaded from .ani files (list of animation names)
+// Rendered with SurfaceAnimatedSprite
+```
+
+---
+
+## 4. System Interactions & Data Flow
+
+### 4.1 Application Lifecycle
+
+```
+main()
+  ↓
+Director::Director()  [Initialization]
+  ├─ Resource::List::init()  - Initialize asset registry singleton
+  ├─ Director::setFileList() - Load assets.yaml configuration (no verification)
+  ├─ Options::loadFromFile() - Load game configuration
+  ├─ Audio::init()           - Initialize SDL audio
+  ├─ Screen::init()          - Create window, SDL renderer
+  ├─ Input::init()           - Bind keyboard/gamepad controls
+  ├─ Resource::Cache::init() - Load ALL game resources (with verification)
+  │   └─ Throws exception if any required asset is missing
+  └─ Cheevos::init()         - Load achievement state
+
+Director::run()        [Main loop]
+  ├─ while (SceneManager::current != QUIT)
+  │   ├─ Logo::run()
+  │   ├─ LoadingScreen::run()
+  │   ├─ Title::run()
+  │   ├─ Game::run()
+  │   ├─ Ending::run()
+  │   └─ ...
+  └─ return 0
+
+Director::~Director() [Cleanup]
+  ├─ Options::saveToFile()   - Save game settings
+  ├─ Resource::Cache::destroy()
+  ├─ Audio::destroy()
+  ├─ Input::destroy()
+  ├─ Screen::destroy()
+  └─ Resource::List::destroy()
+```
+
+### 4.2 Game Scene Flow (Core Gameplay Loop)
+
+```cpp
+Game::run() {
+    while (game is running) {
+        // Update
+        Input::checkInput()          - Get player commands
+        Player::update()             - Physics, animation, collision
+        Room::update()               - Enemy AI, animated tiles
+        checkCollisions()            - Player vs enemies, items, room
+        checkGameOver()              - Win/lose conditions
+        
+        // Render
+        Screen::start()              - Prepare for drawing
+        Room::renderMap()            - Draw tilemap
+        Room::renderEnemies()        - Draw enemy sprites
+        Room::renderItems()          - Draw item sprites
+        Player::render()             - Draw player sprite
+        renderScoreboard()           - Draw HUD
+        Screen::render()             - Flush to GPU
+    }
+}
+```
+
+### 4.3 Resource Loading & Caching
+
+```
+Director::setFileList()
+  └─ Asset::loadFromFile(config_path, PREFIX, system_folder_)
+      ├─ Read config/assets.yaml                - Parse text configuration file
+      ├─ Parse YAML structure: assets grouped by category
+      ├─ Replace variables (${PREFIX}, ${SYSTEM_FOLDER})
+      └─ Store in unordered_map (O(1) lookup) - Fast asset path retrieval
+
+Game Scene initialization
+  └─ Resource::Cache::init() - Loads all resources
+      ├─ loadSounds()        - WAV files (with error handling)
+      ├─ loadMusics()        - OGG files (with error handling)
+      ├─ loadSurfaces()      - GIF/PNG images (with error handling)
+      ├─ loadPalettes()      - PAL palette files (with error handling)
+      ├─ loadTextFiles()     - Font definition files (with error handling)
+      ├─ loadAnimations()    - YAML animation definitions (with error handling)
+      └─ loadRooms()         - Room YAML files (with error handling)
+
+      Note: Asset verification happens during actual loading.
+            If a required file is missing, Cache::load() throws detailed exception.
+
+During gameplay
+  └─ Resource::Cache::get*(name) - Return cached resource
+```
+
+### 4.4 Input Flow
+
+```
+SDL_Event (from OS)
+  ↓
+Input::checkInput(action)
+  ├─ Check keyboard bindings      - SDL_Scancode → InputAction
+  ├─ Check gamepad bindings       - SDL_GamepadButton → InputAction
+  └─ Return true if action active
+
+Game logic uses checked inputs
+  └─ Player responds to actions
+```
+
+### 4.5 Audio Control Flow
+
+```
+Game code
+  ├─ Audio::playMusic(name, loop)
+  ├─ Audio::playSound(name, group)
+  └─ Audio::stopMusic()
+      ↓
+    Audio [wrapper/manager]
+      ├─ Resource::getMusic(name)
+      ├─ Resource::getSound(name)
+      └─ jail_audio C library
+          └─ SDL3 Audio device
+```
+
+---
+
+## 5. Important Design Patterns & Conventions
+
+### 5.1 Naming Conventions
+
+**Classes:**
+- `PascalCase` for classes: `Player`, `Room`, `Screen`, `Director`
+- Suffix `Sprite` for sprite classes: `SurfaceSprite`, `SurfaceAnimatedSprite`
+
+**Methods:**
+- `get*()` for getters: `getWidth()`, `getRect()`
+- `set*()` for setters: `setColor()`, `setPos()`
+- `check*()` for boolean checks: `checkInput()`, `checkCollision()`
+- `update()` for game logic updates
+- `render()` for drawing
+
+**Variables:**
+- `snake_case` for member variables with `_` suffix: `x_`, `y_`, `sprite_`
+- `UPPER_CASE` for constants: `BLOCK`, `MAX_VY`, `WIDTH`
+- Private members: `private_member_`
+
+**Structs for Data:**
+- `XxxData` suffix: `PlayerData`, `RoomData`, `AnimationData`
+- Used as initialization structures passed to constructors
+
+### 5.2 Memory Management
+
+- **Smart Pointers:** Uses `std::shared_ptr` for shared ownership (Surfaces, Sprites, Rooms)
+- **Unique Pointers:** Uses `std::unique_ptr` for sole ownership (Director, local objects)
+- **Raw Pointers:** Minimal use, mainly for singleton access or SDL objects
+- **Static Allocation:** Singletons use static pointer pattern for RAII
+
+### 5.3 Frame-Independent Physics
+
+Uses `DeltaTimer` for delta time calculation:
+
+```cpp
+// In game loop
+float delta = deltaTimer.tick();  // Get seconds since last frame
+
+// Apply to physics
+player.vy_ += gravity * delta;
+player.y_ += player.vy_ * delta;
+```
+
+Provides **time scaling** for slow-motion effects.
+
+### 5.4 Palette System
+
+- 8-bit indexed color (256 colors per palette)
+- Multiple palettes can be loaded and swapped
+- `Surface::setPalette()` changes rendering colors
+- Supports color replacement per-render: `renderWithColorReplace()`
+- CRT shader effects can modify colors in real-time
+
+### 5.5 Configuration System
+
+Game settings stored in configuration file:
+
+```cpp
+namespace Options {
+    inline Video video{};           // Screen resolution, fullscreen, etc.
+    inline Audio audio{};           // Music/sound volumes
+    inline Notification notifications{};
+    inline Cheat cheats{};          // Cheat codes
+    inline ControlScheme keys{};    // Control mapping
+    inline Stats stats{};           // Game statistics
+}
+
+Options::loadFromFile(path);  // Load from config.yaml
+Options::saveToFile(path);    // Save on exit
+```
+
+### 5.6 Achievement System
+
+```cpp
+struct Achievement {
+    int id;
+    std::string caption;
+    std::string description;
+    int icon;
+    bool completed;
+    bool obtainable;
+};
+
+Cheevos::unlock(id);           // Unlock achievement
+Cheevos::setUnobtainable(id);  // Lock achievement
+Cheevos::saveToFile();         // Persist state
+```
+
+Achievements trigger notifications on unlock.
+
+---
+
+## 6. Technology Stack
+
+### Core Technologies
+
+| Component | Technology | Version | Role |
+|-----------|-----------|---------|------|
+| **Graphics** | SDL3 | Latest | Window, rendering, input |
+| **GPU Rendering** | OpenGL | 3.2+ | Shader effects (CRT) |
+| **Audio** | SDL3 Audio | Latest | Audio device, mixing |
+| **Audio Decoding** | jail_audio (custom) | 1.x | OGG/WAV playback |
+| **Image Loading** | stb_image | v2.x | PNG/GIF image loading |
+| **Audio Decoding** | stb_vorbis | v1.x | OGG Vorbis support |
+| **Language** | C++ | C++20 | Standard library features |
+| **Build System** | CMake | 3.10+ | Cross-platform building |
+
+### C++ Features Used
+
+- **Smart Pointers:** `std::shared_ptr`, `std::unique_ptr`
+- **Standard Containers:** `std::vector`, `std::array`
+- **Modern Features:** `std::move`, lambda functions, constexpr
+- **Namespaces:** Extensive use for organization
+- **Inline Variables:** C++17 `inline` for global game state
+
+### Platform Support
+
+- **Windows:** MinGW/MSVC with SDL3
+- **macOS:** Apple Clang, arm64 architecture, OpenGL
+- **Linux:** GCC with SDL3 and OpenGL
+
+---
+
+## 7. Key Classes & Their Responsibilities
+
+### Core System Classes
+
+| Class | Purpose | Pattern |
+|-------|---------|---------|
+| `Director` | Main application controller, scene manager | Singleton |
+| `Screen` | Rendering, window, palette management | Singleton |
+| `Input` | Keyboard & gamepad input | Singleton |
+| `Audio` | Music and SFX playback | Singleton |
+| `Resource::Cache` | Asset caching and loading (with detailed error messages) | Singleton |
+| `Resource::List` | Asset path registry from config/assets.yaml, O(1) lookups, variable substitution | Singleton |
+| `Debug` | Debug overlay information | Singleton |
+| `globalEvents` | Global SDL event handling (quit, device reset, mouse) | Namespace |
+
+### Game Logic Classes
+
+| Class | Purpose |
+|-------|---------|
+| `Game` | Main gameplay scene, orchestrates update/render |
+| `Player` | Player entity with physics and animation |
+| `Room` | Level data, collision detection, tilemap rendering |
+| `Enemy` | Enemy entity behavior and rendering |
+| `Item` | Collectible items |
+| `Scoreboard` | HUD display data |
+| `Cheevos` | Achievement unlock and state |
+| `ItemTracker` | Tracks collected items |
+| `RoomTracker` | Tracks visited rooms |
+
+### Rendering Classes
+
+| Class | Purpose |
+|-------|---------|
+| `Surface` | 8-bit indexed color pixel buffer with palette |
+| `SurfaceSprite` | Renders a sprite region |
+| `SurfaceAnimatedSprite` | Frame-based animation rendering |
+| `SurfaceMovingSprite` | Sprite with velocity/position |
+| `Text` | Text rendering system |
+| `OpenGLShader` | Shader compilation and effects |
+
+### Utility Classes
+
+| Class | Purpose |
+|-------|---------|
+| `DeltaTimer` | Frame-rate independent timing |
+
+---
+
+## 8. Common Development Workflows
+
+### Adding a New Input Action
+
+1. Add to `InputAction` enum in `core/input/input.hpp`
+2. Bind in `Director::initInput()`:
+   ```cpp
+   Input::get()->bindKey(InputAction::NEW_ACTION, SDL_SCANCODE_X);
+   ```
+3. Check in game code:
+   ```cpp
+   if (Input::get()->checkInput(InputAction::NEW_ACTION)) {
+       // Handle action
+   }
+   ```
+
+### Adding a New Scene
+
+1. Create class inheriting appropriate base (usually standalone `run()` method)
+2. Add to `SceneManager::Scene` enum
+3. Implement in `Director::run()` switch statement
+4. Set `SceneManager::current` to transition
+
+### Adding Game Assets
+
+1. Place file in `data/` directory
+2. Add entry to `config/assets.yaml` under the appropriate category:
+   ```yaml
+   assets:
+     category_name:  # e.g., player, enemies, music, etc.
+       - type: BITMAP
+         path: ${PREFIX}/data/path/file.ext
+   ```
+   Available types: `DATA`, `BITMAP`, `ANIMATION`, `MUSIC`, `SOUND`, `FONT`, `ROOM`, `PALETTE`
+3. Optional flags can be added:
+   ```yaml
+   - type: DATA
+     path: ${SYSTEM_FOLDER}/file.txt
+     required: false  # Don't fail if missing
+     absolute: true   # Path is absolute
+   ```
+4. Resource loads automatically during `Resource::init()`
+5. Access via: `Resource::Cache::get()->getSurface("name")`
+
+**Note:** No recompilation needed when adding/removing/modifying assets in `config/assets.yaml`
+
+### Modifying Collision Detection
+
+1. Update `Room::setBottomSurfaces()`, `setLeftSlopes()`, etc.
+2. Modify Player collision point generation in `Player::updateColliderPoints()`
+3. Adjust tile classification in `TileType` enum
+4. Test with debug visualization (F12 key)
+
+---
+
+## 9. Debug Features
+
+### Available at Runtime
+
+- **F12** - Toggle debug info overlay (FPS, player position, collision points)
+- **F1/F2** - Decrease/increase window zoom
+- **F3** - Toggle fullscreen mode
+- **F4** - Toggle shader effects
+- **F5/F6** - Next/previous palette
+- **F7** - Toggle integer scaling
+- **M** - Toggle music
+- **B** - Toggle border display
+- **P** - Pause game
+
+### Debug Mode Compilation
+
+In debug builds (`#ifdef DEBUG`), renders:
+- Player collision boxes
+- Collision point visualization
+- Debug information overlay
+- Special debug event handling
+
+---
+
+## 10. Performance Considerations
+
+### Optimization Points
+
+1. **Rendering:** Uses indexed color (8-bit) to reduce memory bandwidth
+2. **Surfaces:** Shared smart pointers reduce copying
+3. **Collision:** Pre-computed tile surface lists avoid per-frame searches
+4. **Animation:** Frame-based animation reduces computation vs. bone systems
+5. **Audio:** Cached music and sound effects, no runtime decoding
+6. **Delta Time:** Frame-rate independent logic for smooth gameplay
+
+### Known Limitations
+
+- Single-threaded architecture (SDL3 requires single-thread rendering)
+- Surfaces stored entirely in CPU memory (not GPU-side textures)
+- Palette system requires full surface redraw when changing colors
+
+---
+
+## 11. File Format Reference
+
+### Asset Configuration File (config/assets.yaml)
+YAML-based asset registry with grouped structure:
+```yaml
+# JailDoctor's Dilemma - Asset Configuration
+# Variables: ${PREFIX}, ${SYSTEM_FOLDER}
+
+assets:
+  # FONTS
+  fonts:
+    - type: BITMAP
+      path: ${PREFIX}/data/font/smb2.gif
+    - type: FONT
+      path: ${PREFIX}/data/font/smb2.txt
+
+  # PLAYER
+  player:
+    - type: BITMAP
+      path: ${PREFIX}/data/player/player.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/player/player.yaml
+
+  # MUSIC
+  music:
+    - type: MUSIC
+      path: ${PREFIX}/data/music/title.ogg
+
+  # SYSTEM FILES (optional, absolute paths)
+  system:
+    - type: DATA
+      path: ${SYSTEM_FOLDER}/config.yaml
+      required: false
+      absolute: true
+```
+
+**Asset Structure:**
+- Assets are organized into categories (fonts, palettes, shaders, player, enemies, etc.)
+- Each asset entry contains:
+  - `type` - Asset type (required)
+  - `path` - File path with variable substitution (required)
+  - `required` - Whether file must exist (optional, default: `true`)
+  - `absolute` - Whether path is absolute (optional, default: `false`)
+
+**Available Asset Types:**
+- `DATA` - General data files (text, JSON, etc.)
+- `BITMAP` - Images (GIF, PNG)
+- `ANIMATION` - Animation definition files (.yaml)
+- `MUSIC` - Music files (OGG)
+- `SOUND` - Sound effects (WAV)
+- `FONT` - Font definition files
+- `ROOM` - Room data files (.yaml)
+- `PALETTE` - Color palette files (.pal)
+
+**Variables:**
+- `${PREFIX}` - Replaced with `/../Resources` on macOS bundles, empty otherwise
+- `${SYSTEM_FOLDER}` - Replaced with user's system config folder
+
+### Animation Files (.ani)
+List of animation names, one per line:
+```
+default
+jump
+run
+fall
+```
+
+### Room Data Files (.room)
+Key-value pairs defining room properties:
+```
+number=01
+name=Starting Room
+bg_color=0x000000
+border_color=0xFF00FF
+...
+```
+
+### Tilemap Files (.tmx)
+Tiled map format with tileset and collision data.
+
+### Palette Files (.pal)
+Binary 256-color palette format (256 × 4 bytes RGBA).
+
+---
+
+## 12. Quick Reference: Main Entry Points
+
+### For Graphics Issues
+- `Screen::render()` - Main rendering method
+- `Screen::setPalete()` - Palette application
+- `Surface` class - Pixel buffer operations
+
+### For Input Issues
+- `Input::checkInput()` - Input state checking
+- `Director::initInput()` - Binding configuration
+
+### For Audio Issues
+- `Audio::playMusic()` - Music playback
+- `Audio::playSound()` - SFX playback
+- `jail_audio` library - Low-level audio operations
+
+### For Game Logic
+- `Game::run()` - Main game loop
+- `Room` class - Collision and level logic
+- `Player::update()` - Physics and movement
+
+### For Asset Management
+- `config/assets.yaml` - Asset configuration file (text-based, no recompilation needed)
+- `Asset::loadFromFile()` - Loads assets from config file
+- `Resource::List::get()` - Retrieves asset path (O(1) lookup with unordered_map)
+- `Resource::load()` - Asset loading
+- `Director::setFileList()` - Calls `Asset::loadFromFile()` with PREFIX and system_folder
+
+---
+
+## 13. Future Enhancement Points
+
+### Identified Areas for Expansion
+
+1. **Network Play:** Stats upload to online service
+2. **More Scenes:** Additional game modes
+3. **Custom Rooms:** Level editor integration
+4. **Audio Streaming:** Background music without loading entire file
+5. **Particle System:** Visual effects for pickups/collisions
+6. **Controller Feedback:** Haptic feedback for game events
+7. **Accessibility:** Font scaling, color-blind modes, key remapping UI
+
+---
+
+## Development Notes
+
+- **Language:** All code comments and some variable names are in Spanish (maintaining original author style)
+- **Compilation:** Use CMake - automatically handles platform differences
+- **Performance Profiling:** Use debug overlay (F12) for basic metrics; consider external profilers for deeper analysis
+- **Common Warnings:** The codebase has been cleaned of the `struct`/`class` forward declaration inconsistency warnings that previously appeared
+
+### Important Code Consistency Rules
+
+1. **Forward Declarations:** Always use `class` for forward declarations of classes defined with `class` (not `struct`). The `Surface` class is defined as `class Surface` in `surface.hpp:57`, so all forward declarations must use `class Surface;`
+
+2. **Singleton Pattern:** When creating new singletons, follow the existing pattern:
+   - Private static instance pointer
+   - Private constructor/destructor
+   - Public `init()`, `destroy()`, and `get()` methods
+
+3. **Delta Time:** Always use `DeltaTimer` for frame-rate independent physics calculations
+
+4. **Memory Management:** Prefer `std::shared_ptr` for shared resources (Surfaces, Sprites) and `std::unique_ptr` for sole ownership
+
+---
+
+**Last Updated:** November 2022 (per README)
+**Original Author:** JailDesigner
+**Repository:** Gitea (internal)

CMakeLists.txt

@@ -3,83 +3,236 @@
 cmake_minimum_required(VERSION 3.10)
 project(jaildoctors_dilemma VERSION 1.00)
 
-# Configuración de compilador para MinGW en Windows, si es necesario
-if(WIN32 AND NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-    set(CMAKE_CXX_COMPILER "g++")
-    set(CMAKE_C_COMPILER "gcc")
-endif()
-
 # Establecer estándar de C++
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 
-# Configuración global de flags de compilación
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Os -ffunction-sections -fdata-sections")
+# Exportar comandos de compilación para herramientas de análisis
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-# Define el directorio de los archivos fuente
-set(DIR_SOURCES "${CMAKE_SOURCE_DIR}/source")
+# Establece la política CMP0072 para indicar cómo se debe seleccionar la implementación de OpenGL.
+# En este caso, se elige la opción "GLVND", que utiliza bibliotecas modernas y modulares (libOpenGL, libGLX),
+# en lugar de la biblioteca OpenGL clásica (libGL). Esto mejora la compatibilidad con drivers recientes
+# y evita ambigüedades cuando se encuentran múltiples implementaciones de OpenGL en el sistema.
+cmake_policy(SET CMP0072 NEW)
+set(OpenGL_GL_PREFERENCE GLVND)
 
-# Cargar todos los archivos fuente en DIR_SOURCES
-file(GLOB SOURCES "${DIR_SOURCES}/*.cpp")
-
-# Verificar si se encontraron archivos fuente
-if(NOT SOURCES)
-    message(FATAL_ERROR "No se encontraron archivos fuente en ${DIR_SOURCES}. Verifica que el directorio existe y contiene archivos .cpp.")
-endif()
-
-# Configuración de SDL2
-find_package(SDL2 REQUIRED)
-if(SDL2_FOUND)
-    message(STATUS "SDL2 encontrado: ${SDL2_INCLUDE_DIRS}")
-    include_directories(${SDL2_INCLUDE_DIRS})
-    link_directories(${SDL2_LIBDIR})
+# --- 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()
-    message(FATAL_ERROR "SDL2 no encontrado")
+    set(GIT_HASH "unknown")
 endif()
 
-# Incluye rutas de SDL2 obtenidas con pkg-config
-include_directories(/usr/local/include /usr/local/include/SDL2)
-link_directories(/usr/local/lib)
+# Configurar archivo de versión
+configure_file(${CMAKE_SOURCE_DIR}/source/version.h.in ${CMAKE_BINARY_DIR}/version.h @ONLY)
 
-# Definir las bibliotecas comunes
-set(LIBS SDL2)
+# --- 1. LISTA EXPLÍCITA DE FUENTES ---
+set(APP_SOURCES
+    # Core - Audio
+    source/core/audio/audio.cpp
 
-# Configuración común de salida de ejecutables en el directorio raíz
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR})
+    # Core - Input
+    source/core/input/global_inputs.cpp
+    source/core/input/input.cpp
+    source/core/input/input_types.cpp
+    source/core/input/mouse.cpp
 
-# Añadir ejecutable principal
-add_executable(${PROJECT_NAME} ${SOURCES})
+    # Core - Rendering
+    source/core/rendering/gif.cpp
+    source/core/rendering/screen.cpp
+    source/core/rendering/surface.cpp
+    source/core/rendering/surface_animated_sprite.cpp
+    source/core/rendering/surface_moving_sprite.cpp
+    source/core/rendering/surface_sprite.cpp
+    source/core/rendering/text.cpp
+    source/core/rendering/texture.cpp
 
-# Añadir definiciones de compilación dependiendo del tipo de build
-target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:DEBUG>:DEBUG VERBOSE>)
+    # Core - Resources
+    source/core/resources/resource_list.cpp
+    source/core/resources/resource_cache.cpp
+    source/core/resources/resource_pack.cpp
+    source/core/resources/resource_loader.cpp
+    source/core/resources/resource_helper.cpp
 
-# Enlazar bibliotecas
-target_link_libraries(${PROJECT_NAME} ${LIBS})
+    # Core - System
+    source/core/system/director.cpp
+    source/core/system/global_events.cpp
+
+    # Game - Entities
+    source/game/entities/enemy.cpp
+    source/game/entities/item.cpp
+    source/game/entities/player.cpp
+
+    # Game - Configuration
+    source/game/options.cpp
+
+    # Game - Gameplay
+    source/game/gameplay/cheevos.cpp
+    source/game/gameplay/collision_map.cpp
+    source/game/gameplay/enemy_manager.cpp
+    source/game/gameplay/item_manager.cpp
+    source/game/gameplay/item_tracker.cpp
+    source/game/gameplay/room.cpp
+    source/game/gameplay/room_loader.cpp
+    source/game/gameplay/room_tracker.cpp
+    source/game/gameplay/scoreboard.cpp
+    source/game/gameplay/stats.cpp
+    source/game/gameplay/tilemap_renderer.cpp
+
+    # Game - Scenes
+    source/game/scenes/credits.cpp
+    source/game/scenes/ending.cpp
+    source/game/scenes/ending2.cpp
+    source/game/scenes/game.cpp
+    source/game/scenes/game_over.cpp
+    source/game/scenes/loading_screen.cpp
+    source/game/scenes/logo.cpp
+    source/game/scenes/title.cpp
+
+    # Game - UI
+    source/game/ui/notifier.cpp
+
+    # Utils
+    source/utils/delta_timer.cpp
+    source/utils/utils.cpp
+
+    # Main
+    source/main.cpp
+)
+
+# Fuentes del sistema de renderizado
+set(RENDERING_SOURCES
+    source/core/rendering/opengl/opengl_shader.cpp
+)
+
+# Fuentes de debug (solo en modo Debug)
+set(DEBUG_SOURCES
+    source/core/system/debug.cpp
+)
+
+# Configuración de SDL3
+find_package(SDL3 REQUIRED CONFIG REQUIRED COMPONENTS SDL3)
+message(STATUS "SDL3 encontrado: ${SDL3_INCLUDE_DIRS}")
+
+# --- 2. AÑADIR EJECUTABLE ---
+add_executable(${PROJECT_NAME} ${APP_SOURCES} ${RENDERING_SOURCES})
+
+# Añadir fuentes de debug solo en modo Debug
+target_sources(${PROJECT_NAME} PRIVATE $<$<CONFIG:Debug>:${DEBUG_SOURCES}>)
+
+# --- 3. DIRECTORIOS DE INCLUSIÓN ---
+target_include_directories(${PROJECT_NAME} PUBLIC
+    "${CMAKE_SOURCE_DIR}/source"
+    "${CMAKE_BINARY_DIR}"
+)
+
+# Enlazar las librerías SDL3
+target_link_libraries(${PROJECT_NAME} PRIVATE SDL3::SDL3)
+
+
+# --- 4. CONFIGURACIÓN PLATAFORMAS Y COMPILADOR  ---
+# Configuración de flags de compilación
+target_compile_options(${PROJECT_NAME} PRIVATE -Wall)
+target_compile_options(${PROJECT_NAME} PRIVATE $<$<CONFIG:RELEASE>:-Os -ffunction-sections -fdata-sections>)
+
+# Definir _DEBUG en modo Debug y RELEASE_BUILD en modo Release
+target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:DEBUG>:_DEBUG>)
+target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:RELEASE>:RELEASE_BUILD>)
 
 # Configuración específica para cada plataforma
 if(WIN32)
     target_compile_definitions(${PROJECT_NAME} PRIVATE WINDOWS_BUILD)
-    target_link_libraries(${PROJECT_NAME} mingw32 opengl32 gdi32 winmm imm32 ole32 version)
+    target_link_libraries(${PROJECT_NAME} PRIVATE ws2_32 mingw32 opengl32)
 elseif(APPLE)
-    set(LIBS ${LIBS} "-framework OpenGL")
     target_compile_definitions(${PROJECT_NAME} PRIVATE MACOS_BUILD)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated")
-    # Configurar compilación para Apple Silicon
+    target_compile_options(${PROJECT_NAME} PRIVATE -Wno-deprecated)
     set(CMAKE_OSX_ARCHITECTURES "arm64")
 elseif(UNIX AND NOT APPLE)
-    set(LIBS ${LIBS} GL)
     target_compile_definitions(${PROJECT_NAME} PRIVATE LINUX_BUILD)
-    target_link_libraries(${PROJECT_NAME} ${LIBS})
 endif()
 
-# Añadir OpenGL a las bibliotecas enlazadas
+# Configuración común para OpenGL
 if(NOT WIN32)
     find_package(OpenGL REQUIRED)
     if(OPENGL_FOUND)
         message(STATUS "OpenGL encontrado: ${OPENGL_LIBRARIES}")
-        target_link_libraries(${PROJECT_NAME} ${OPENGL_LIBRARIES})
+        target_link_libraries(${PROJECT_NAME} PRIVATE ${OPENGL_LIBRARIES})
     else()
         message(FATAL_ERROR "OpenGL no encontrado")
     endif()
 endif()
+
+# Especificar la ubicación del ejecutable
+set_target_properties(${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR})
+
+# --- 5. STATIC ANALYSIS TARGETS ---
+
+# Buscar herramientas de análisis estático
+find_program(CLANG_TIDY_EXE NAMES clang-tidy)
+find_program(CLANG_FORMAT_EXE NAMES clang-format)
+
+# Recopilar todos los archivos fuente para formateo
+file(GLOB_RECURSE ALL_SOURCE_FILES
+    "${CMAKE_SOURCE_DIR}/source/*.cpp"
+    "${CMAKE_SOURCE_DIR}/source/*.hpp"
+    "${CMAKE_SOURCE_DIR}/source/*.h"
+)
+
+# 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$")
+
+# Targets de clang-tidy
+if(CLANG_TIDY_EXE)
+    add_custom_target(tidy
+        COMMAND ${CLANG_TIDY_EXE}
+            -p ${CMAKE_BINARY_DIR}
+            ${CLANG_TIDY_SOURCES}
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Running clang-tidy..."
+    )
+
+    add_custom_target(tidy-fix
+        COMMAND ${CLANG_TIDY_EXE}
+            -p ${CMAKE_BINARY_DIR}
+            --fix
+            ${CLANG_TIDY_SOURCES}
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Running clang-tidy with fixes..."
+    )
+else()
+    message(STATUS "clang-tidy no encontrado - targets 'tidy' y 'tidy-fix' no disponibles")
+endif()
+
+# Targets de clang-format
+if(CLANG_FORMAT_EXE)
+    add_custom_target(format
+        COMMAND ${CLANG_FORMAT_EXE}
+            -i
+            ${ALL_SOURCE_FILES}
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Running clang-format..."
+    )
+
+    add_custom_target(format-check
+        COMMAND ${CLANG_FORMAT_EXE}
+            --dry-run
+            --Werror
+            ${ALL_SOURCE_FILES}
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Checking clang-format..."
+    )
+else()
+    message(STATUS "clang-format no encontrado - targets 'format' y 'format-check' no disponibles")
+endif()

LICENSE

@@ -1 +1,21 @@
-GNU General Public License v3.0 only
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License
+
+Copyright (c) 2022 JailDoctor's Dilemma
+
+This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
+
+You are free to:
+- Share — copy and redistribute the material in any medium or format
+- Adapt — remix, transform, and build upon the material
+
+Under the following terms:
+- Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
+- NonCommercial — You may not use the material for commercial purposes.
+- ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.
+
+No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
+
+To view a copy of this license, visit:
+https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Makefile

@@ -1,145 +1,401 @@
-executable = jaildoctors_dilemma
-source = source/*.cpp
-appName = JailDoctor's Dilemma
-releaseFolder = jdd_release
-version = v1.09
+# ==============================================================================
+# DIRECTORIES
+# ==============================================================================
+DIR_ROOT       := $(dir $(abspath $(MAKEFILE_LIST)))
+DIR_SOURCES    := $(addsuffix /, $(DIR_ROOT)source)
+DIR_BIN        := $(addsuffix /, $(DIR_ROOT))
+DIR_TOOLS      := $(addsuffix /, $(DIR_ROOT)tools)
 
-# Release names
-windowsRelease = $(executable)-$(version)-win32-x64.zip
-macosIntelRelease = $(executable)-$(version)-macos-intel.dmg
-macosAppleSiliconRelease = $(executable)-$(version)-macos-apple-silicon.dmg
-linuxRelease = $(executable)-$(version)-linux.tar.gz
+# ==============================================================================
+# TARGET NAMES
+# ==============================================================================
+TARGET_NAME    := jaildoctors_dilemma
+TARGET_FILE    := $(DIR_BIN)$(TARGET_NAME)
+APP_NAME       := JailDoctor's Dilemma
+RELEASE_FOLDER := jdd_release
+RELEASE_FILE   := $(RELEASE_FOLDER)/$(TARGET_NAME)
+RESOURCE_FILE  := release/jdd.res
 
-# Specify the C++ standard
-cpp_standard = c++20
+# ==============================================================================
+# PACKING TOOL
+# ==============================================================================
+ifeq ($(OS),Windows_NT)
+    PACK_TOOL      := $(DIR_TOOLS)pack_resources/pack_resources.exe
+    PACK_CXX       := $(CXX)
+else
+    PACK_TOOL      := $(DIR_TOOLS)pack_resources/pack_resources
+    PACK_CXX       := $(CXX)
+endif
+PACK_SOURCES   := $(DIR_TOOLS)pack_resources/pack_resources.cpp source/core/resources/resource_pack.cpp
+PACK_INCLUDES  := -Isource
 
+# ==============================================================================
+# 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")
+else
+    VERSION := v$(shell grep 'constexpr const char\* VERSION' source/utils/defines.hpp | sed -E 's/.*VERSION = "([^"]+)".*/\1/')
+endif
+
+# ==============================================================================
+# WINDOWS-SPECIFIC VARIABLES
+# ==============================================================================
+ifeq ($(OS),Windows_NT)
+    WIN_TARGET_FILE    := $(DIR_BIN)$(APP_NAME)
+    WIN_RELEASE_FILE   := $(RELEASE_FOLDER)/$(APP_NAME)
+else
+    WIN_TARGET_FILE    := $(TARGET_FILE)
+    WIN_RELEASE_FILE   := $(RELEASE_FILE)
+endif
+
+# ==============================================================================
+# RELEASE NAMES
+# ==============================================================================
+WINDOWS_RELEASE             := $(TARGET_NAME)-$(VERSION)-win32-x64.zip
+MACOS_INTEL_RELEASE         := $(TARGET_NAME)-$(VERSION)-macos-intel.dmg
+MACOS_APPLE_SILICON_RELEASE := $(TARGET_NAME)-$(VERSION)-macos-apple-silicon.dmg
+LINUX_RELEASE               := $(TARGET_NAME)-$(VERSION)-linux.tar.gz
+
+# ==============================================================================
+# SOURCE FILES
+# ==============================================================================
+APP_SOURCES := \
+    source/main.cpp \
+    source/core/audio/audio.cpp \
+    source/core/input/input.cpp \
+    source/core/input/input_types.cpp \
+    source/core/input/mouse.cpp \
+    source/core/input/global_inputs.cpp \
+    source/core/rendering/screen.cpp \
+    source/core/rendering/surface.cpp \
+    source/core/rendering/surface_sprite.cpp \
+    source/core/rendering/surface_animated_sprite.cpp \
+    source/core/rendering/surface_moving_sprite.cpp \
+    source/core/rendering/text.cpp \
+    source/core/rendering/texture.cpp \
+    source/core/rendering/gif.cpp \
+    source/core/rendering/opengl/opengl_shader.cpp \
+    source/core/resources/resource_list.cpp \
+    source/core/resources/resource_cache.cpp \
+    source/core/resources/resource_helper.cpp \
+    source/core/resources/resource_loader.cpp \
+    source/core/resources/resource_pack.cpp \
+    source/core/system/director.cpp \
+    source/core/system/debug.cpp \
+    source/core/system/global_events.cpp \
+    source/game/options.cpp \
+    source/game/entities/player.cpp \
+    source/game/entities/enemy.cpp \
+    source/game/entities/item.cpp \
+    source/game/gameplay/room.cpp \
+    source/game/gameplay/collision_map.cpp \
+    source/game/gameplay/enemy_manager.cpp \
+    source/game/gameplay/item_manager.cpp \
+    source/game/gameplay/room_loader.cpp \
+    source/game/gameplay/tilemap_renderer.cpp \
+    source/game/gameplay/scoreboard.cpp \
+    source/game/gameplay/cheevos.cpp \
+    source/game/gameplay/item_tracker.cpp \
+    source/game/gameplay/room_tracker.cpp \
+    source/game/gameplay/stats.cpp \
+    source/game/scenes/logo.cpp \
+    source/game/scenes/loading_screen.cpp \
+    source/game/scenes/title.cpp \
+    source/game/scenes/game.cpp \
+    source/game/scenes/game_over.cpp \
+    source/game/scenes/ending.cpp \
+    source/game/scenes/ending2.cpp \
+    source/game/scenes/credits.cpp \
+    source/game/ui/notifier.cpp \
+    source/utils/utils.cpp \
+    source/utils/delta_timer.cpp
+
+# All sources combined
+ALL_SOURCES := $(APP_SOURCES)
+
+# ==============================================================================
+# INCLUDES
+# ==============================================================================
+INCLUDES := -Isource
+
+# ==============================================================================
+# COMPILER FLAGS (OS-specific)
+# ==============================================================================
+CPP_STANDARD := c++20
+
+ifeq ($(OS),Windows_NT)
+    FixPath         = $(subst /,\\,$1)
+    CXXFLAGS        := -std=$(CPP_STANDARD) -Wall -Os -ffunction-sections -fdata-sections \
+                       -Wl,--gc-sections -static-libstdc++ -static-libgcc \
+                       -Wl,-subsystem,windows -DWINDOWS_BUILD
+    CXXFLAGS_DEBUG  := -std=$(CPP_STANDARD) -Wall -g -D_DEBUG -DWINDOWS_BUILD
+    LDFLAGS         := -lmingw32 -lws2_32 -lSDL3 -lopengl32
+    RM              := del /Q
+    MKDIR           := mkdir
+else
+    FixPath         = $1
+    CXXFLAGS        := -std=$(CPP_STANDARD) -Wall -Os -ffunction-sections -fdata-sections
+    CXXFLAGS_DEBUG  := -std=$(CPP_STANDARD) -Wall -g -D_DEBUG
+    LDFLAGS         := -lSDL3
+    RMFILE          := rm -f
+    RMDIR           := rm -rdf
+    MKDIR           := mkdir -p
+    UNAME_S         := $(shell uname -s)
+    ifeq ($(UNAME_S),Linux)
+        CXXFLAGS    += -DLINUX_BUILD
+        LDFLAGS     += -lGL
+    endif
+    ifeq ($(UNAME_S),Darwin)
+        CXXFLAGS       += -Wno-deprecated -DMACOS_BUILD
+        CXXFLAGS_DEBUG += -Wno-deprecated -DMACOS_BUILD
+        LDFLAGS        += -framework OpenGL
+        # Configurar arquitectura (por defecto arm64)
+        CXXFLAGS       += -arch arm64
+        CXXFLAGS_DEBUG += -arch arm64
+    endif
+endif
+
+# ==============================================================================
+# REGLAS PARA HERRAMIENTA DE EMPAQUETADO Y RESOURCES.PACK
+# ==============================================================================
+$(PACK_TOOL): FORCE
+	@echo "Compilando herramienta de empaquetado..."
+	$(PACK_CXX) -std=$(CPP_STANDARD) -Wall -Os $(PACK_INCLUDES) $(PACK_SOURCES) -o $(PACK_TOOL)
+	@echo "✓ Herramienta de empaquetado lista: $(PACK_TOOL)"
+
+pack_tool: $(PACK_TOOL)
+
+resources.pack: $(PACK_TOOL)
+	@echo "Generando resources.pack desde directorio data/..."
+	$(PACK_TOOL) data resources.pack
+	@echo "✓ resources.pack generado exitosamente"
+
+# ==============================================================================
+# COMPILACIÓN PARA WINDOWS
+# ==============================================================================
 windows:
 	@echo off
-	g++ $(source) -std=$(cpp_standard) -Wall -Os -lmingw32 -lws2_32 -lSDL2main -lSDL2 -lopengl32 -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows -o "$(executable).exe"
-	strip -s -R .comment -R .gnu.version "$(executable).exe" --strip-unneeded
+	@echo Compilando para Windows con nombre: "$(WIN_TARGET_FILE).exe"
+	windres release/jdd.rc -O coff -o $(RESOURCE_FILE)
+	g++ $(ALL_SOURCES) $(RESOURCE_FILE) $(INCLUDES) $(CXXFLAGS) $(LDFLAGS) -o "$(WIN_TARGET_FILE).exe"
+	strip -s -R .comment -R .gnu.version "$(WIN_TARGET_FILE).exe" --strip-unneeded
 
 windows_debug:
 	@echo off
-	g++ $(source) -D DEBUG -std=$(cpp_standard) -Wall -Os -lmingw32 -lws2_32 -lSDL2main -lSDL2 -lopengl32 -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows -o "$(executable)_debug.exe"
-	strip -s -R .comment -R .gnu.version "$(executable)_debug.exe" --strip-unneeded
+	@echo Compilando version debug para Windows: "$(WIN_TARGET_FILE)_debug.exe"
+	g++ $(ALL_SOURCES) $(INCLUDES) -DDEBUG -DVERBOSE $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(WIN_TARGET_FILE)_debug.exe"
 
 windows_release:
+	@$(MAKE) pack_tool
+	@$(MAKE) resources.pack
 	@echo off
+	@echo Creando release para Windows - Version: $(VERSION)
 
-# Create release folder
-	powershell if (Test-Path "$(releaseFolder)") {Remove-Item "$(releaseFolder)" -Recurse -Force}
-	powershell if (-not (Test-Path "$(releaseFolder)")) {New-Item "$(releaseFolder)" -ItemType Directory}
+# Generate version.h from version.h.in
+	@echo "Generando version.h..."
+	@powershell -Command "$$GIT_HASH = (git rev-parse --short=7 HEAD 2>$$null); if (-not $$GIT_HASH) { $$GIT_HASH = 'unknown' }; (Get-Content source/version.h.in) -replace '@GIT_HASH@', $$GIT_HASH | Set-Content source/version.h"
 
-# Prepare data folder
-	powershell Copy-Item -Path "data" -Destination "$(releaseFolder)" -recurse -Force
-	powershell if (Test-Path "$(releaseFolder)\data\room\map.world") {Remove-Item "$(releaseFolder)\data\room\map.world" -Recurse -Force}
-	powershell if (Test-Path "$(releaseFolder)\data\room\standard.tsx") {Remove-Item "$(releaseFolder)\data\room\standard.tsx" -Recurse -Force}
-	
-# Copy root files
-	powershell Copy-Item "LICENSE" -Destination "$(releaseFolder)"
-	powershell Copy-Item "README.md" -Destination "$(releaseFolder)"
-	powershell Copy-Item "release\*.dll" -Destination "$(releaseFolder)"
+# Crea carpeta temporal 'RELEASE_FOLDER'
+	powershell if (Test-Path "$(RELEASE_FOLDER)") {Remove-Item "$(RELEASE_FOLDER)" -Recurse -Force}
+	powershell if (-not (Test-Path "$(RELEASE_FOLDER)")) {New-Item "$(RELEASE_FOLDER)" -ItemType Directory}
 
-# Build
-	g++ $(source) -std=$(cpp_standard) -Wall -Os -lmingw32 -lws2_32 -lSDL2main -lSDL2 -lopengl32 -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows -o "$(releaseFolder)/$(executable).exe"
-	strip -s -R .comment -R .gnu.version "$(releaseFolder)/$(executable).exe" --strip-unneeded
+# Copia el archivo 'resources.pack'
+	powershell Copy-Item -Path "resources.pack" -Destination "$(RELEASE_FOLDER)"
 
-# Create ZIP
-	powershell if (Test-Path $(windowsRelease)) {Remove-Item $(windowsRelease)}
-	powershell Compress-Archive -Path "$(releaseFolder)"/* -DestinationPath $(windowsRelease)
+# Copia los ficheros que están en la raíz del proyecto
+	powershell Copy-Item "LICENSE" -Destination "$(RELEASE_FOLDER)"
+	powershell Copy-Item "README.md" -Destination "$(RELEASE_FOLDER)"
+	powershell Copy-Item "gamecontrollerdb.txt" -Destination "$(RELEASE_FOLDER)"
+	powershell Copy-Item "release\*.dll" -Destination "$(RELEASE_FOLDER)"
 
-# Remove folder
-	powershell if (Test-Path "$(releaseFolder)") {Remove-Item "$(releaseFolder)" -Recurse -Force}
+# Compila (con icono)
+	windres release/jdd.rc -O coff -o $(RESOURCE_FILE)
+	g++ $(ALL_SOURCES) $(RESOURCE_FILE) $(INCLUDES) -DRELEASE_BUILD $(CXXFLAGS) $(LDFLAGS) -o "$(WIN_RELEASE_FILE).exe"
+	strip -s -R .comment -R .gnu.version "$(WIN_RELEASE_FILE).exe" --strip-unneeded
 
+# Crea el fichero .zip
+	powershell if (Test-Path "$(WINDOWS_RELEASE)") {Remove-Item "$(WINDOWS_RELEASE)"}
+	powershell Compress-Archive -Path "$(RELEASE_FOLDER)"/* -DestinationPath "$(WINDOWS_RELEASE)"
+	@echo Release creado: $(WINDOWS_RELEASE)
+
+# Elimina la carpeta temporal 'RELEASE_FOLDER'
+	powershell if (Test-Path "$(RELEASE_FOLDER)") {Remove-Item "$(RELEASE_FOLDER)" -Recurse -Force}
+
+# ==============================================================================
+# COMPILACIÓN PARA MACOS
+# ==============================================================================
 macos:
-	clang++ $(source) -std=$(cpp_standard) -Wall -Os -lSDL2 -framework OpenGL -Wno-deprecated -ffunction-sections -fdata-sections -o "$(executable)"
+	@echo "Compilando para macOS: $(TARGET_NAME)"
+	clang++ $(ALL_SOURCES) $(INCLUDES) $(CXXFLAGS) $(LDFLAGS) -o "$(TARGET_FILE)"
 
 macos_debug:
-	clang++ $(source) -D DEBUG -std=$(cpp_standard) -Wall -Os -lSDL2 -framework OpenGL -Wno-deprecated -ffunction-sections -fdata-sections -o "$(executable)_debug"
+	@echo "Compilando version debug para macOS: $(TARGET_NAME)_debug"
+	clang++ $(ALL_SOURCES) $(INCLUDES) -DDEBUG -DVERBOSE $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
 
 macos_release:
-# Remove data and possible data from previous builds
-	rm -rdf "$(releaseFolder)"
-	rm -rdf Frameworks
-	rm -f tmp.dmg
-	rm -f "$(macosIntelRelease)"
-	rm -f "$(macosAppleSiliconRelease)"
+	@$(MAKE) pack_tool
+	@$(MAKE) resources.pack
+	@echo "Creando release para macOS - Version: $(VERSION)"
 
-# Create folders
-	mkdir -p "$(releaseFolder)/$(appName).app/Contents/Frameworks"
-	mkdir -p "$(releaseFolder)/$(appName).app/Contents/MacOS"
-	mkdir -p "$(releaseFolder)/$(appName).app/Contents/Resources"
-	mkdir -p Frameworks
+# Verificar e instalar create-dmg si es necesario
+	@which create-dmg > /dev/null || (echo "Instalando create-dmg..." && brew install create-dmg)
 
-# Copy folders
-	cp -R data "$(releaseFolder)/$(appName).app/Contents/Resources"
-	cp -R release/SDL2.framework "$(releaseFolder)/$(appName).app/Contents/Frameworks"
-	cp -R release/SDL2.framework Frameworks
+# Generate version.h from version.h.in
+	@echo "Generando version.h..."
+	@GIT_HASH=$$(git rev-parse --short=7 HEAD 2>/dev/null || echo "unknown"); \
+	sed "s/@GIT_HASH@/$$GIT_HASH/g" source/version.h.in > source/version.h
 
-# Delete data
-	rm -f "$(releaseFolder)/$(appName).app/Contents/Resources/data/room/map.world"
-	rm -f "$(releaseFolder)/$(appName).app/Contents/Resources/data/room/standard.tsx"
+# Elimina datos de compilaciones anteriores
+	$(RMDIR) "$(RELEASE_FOLDER)"
+	$(RMDIR) Frameworks
+	$(RMFILE) tmp.dmg
+	$(RMFILE) "$(MACOS_INTEL_RELEASE)"
+	$(RMFILE) "$(MACOS_APPLE_SILICON_RELEASE)"
 
-# Copy files
-	cp release/*.icns "$(releaseFolder)/$(appName).app/Contents/Resources"
-	cp release/Info.plist "$(releaseFolder)/$(appName).app/Contents"
-	cp LICENSE "$(releaseFolder)"
-	cp README.md "$(releaseFolder)"
+# Crea la carpeta temporal para hacer el trabajo y las carpetas obligatorias para crear una app de macOS
+	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks"
+	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS"
+	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
+	$(MKDIR) Frameworks
 
-# Create links
-	ln -s /Applications "$(releaseFolder)"/Applications
+# Copia carpetas y ficheros
+	cp resources.pack "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
+	cp gamecontrollerdb.txt "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
+	cp -R release/frameworks/SDL3.xcframework/macos-arm64_x86_64/SDL3.framework "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks"
+	cp -R release/frameworks/SDL3.xcframework/macos-arm64_x86_64/SDL3.framework Frameworks
+	cp release/*.icns "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
+	cp release/Info.plist "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents"
+	cp LICENSE "$(RELEASE_FOLDER)"
+	cp README.md "$(RELEASE_FOLDER)"
 
-# Build INTEL
-	clang++ $(source) -D MACOS_BUNDLE -std=$(cpp_standard) -Wall -Os -framework SDL2 -F ./Frameworks -framework OpenGL -Wno-deprecated  -ffunction-sections -fdata-sections -o "$(releaseFolder)/$(appName).app/Contents/MacOS/$(executable)" -rpath @executable_path/../Frameworks/ -target x86_64-apple-macos10.12
+# Actualiza versión en Info.plist
+	@echo "Actualizando Info.plist con versión $(VERSION)..."
+	@RAW_VERSION=$$(echo "$(VERSION)" | sed 's/^v//'); \
+	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"
 
-# Build INTEL DMG
-	hdiutil create tmp.dmg -ov -volname "$(appName)" -fs HFS+ -srcfolder "$(releaseFolder)" 
-	hdiutil convert tmp.dmg -format UDZO -o "$(macosIntelRelease)"
-	rm -f tmp.dmg
+# Compila la versión para procesadores Intel
+	clang++ $(ALL_SOURCES) $(INCLUDES) -DMACOS_BUNDLE -DRELEASE_BUILD -std=$(CPP_STANDARD) -Wall -Os -framework SDL3 -F ./Frameworks -framework OpenGL -Wno-deprecated -ffunction-sections -fdata-sections -o "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_NAME)" -rpath @executable_path/../Frameworks/ -target x86_64-apple-macos10.15
 
-# Build APPLE SILICON	
-	clang++ $(source) -D MACOS_BUNDLE -std=$(cpp_standard) -Wall -Os -framework SDL2 -F ./Frameworks -framework OpenGL -Wno-deprecated  -ffunction-sections -fdata-sections -o "$(releaseFolder)/$(appName).app/Contents/MacOS/$(executable)" -rpath @executable_path/../Frameworks/ -target arm64-apple-macos11
+# Firma la aplicación
+	codesign --deep --force --sign - --timestamp=none "$(RELEASE_FOLDER)/$(APP_NAME).app"
 
-# Build APPLE SILICON DMG
-	hdiutil create tmp.dmg -ov -volname "$(appName)" -fs HFS+ -srcfolder "$(releaseFolder)" 
-	hdiutil convert tmp.dmg -format UDZO -o "$(macosAppleSiliconRelease)"
-	rm -f tmp.dmg
+# 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)"
 
-# Remove data
-	rm -rdf Frameworks
-	rm -rdf "$(releaseFolder)"
+# Compila la versión para procesadores Apple Silicon
+	clang++ $(ALL_SOURCES) $(INCLUDES) -DMACOS_BUNDLE -DRELEASE_BUILD -std=$(CPP_STANDARD) -Wall -Os -framework SDL3 -F ./Frameworks -framework OpenGL -Wno-deprecated -ffunction-sections -fdata-sections -o "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_NAME)" -rpath @executable_path/../Frameworks/ -target arm64-apple-macos11
 
+# Firma la aplicación
+	codesign --deep --force --sign - --timestamp=none "$(RELEASE_FOLDER)/$(APP_NAME).app"
+
+# Empaqueta el .dmg de la versión Apple Silicon con create-dmg
+	@echo "Creando DMG Apple Silicon 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_APPLE_SILICON_RELEASE)" \
+	  "$(RELEASE_FOLDER)" || true
+	@echo "Release Apple Silicon creado: $(MACOS_APPLE_SILICON_RELEASE)"
+
+# Elimina las carpetas temporales
+	$(RMDIR) Frameworks
+	$(RMDIR) "$(RELEASE_FOLDER)"
+
+# ==============================================================================
+# COMPILACIÓN PARA LINUX
+# ==============================================================================
 linux:
-	g++ $(source) -std=$(cpp_standard) -Wall -Os -lSDL2 -lGL -ffunction-sections -fdata-sections -Wl,--gc-sections -o "$(executable)"
-	strip -s -R .comment -R .gnu.version "$(executable)" --strip-unneeded
+	@echo "Compilando para Linux: $(TARGET_NAME)"
+	g++ $(ALL_SOURCES) $(INCLUDES) $(CXXFLAGS) $(LDFLAGS) -o "$(TARGET_FILE)"
+	strip -s -R .comment -R .gnu.version "$(TARGET_FILE)" --strip-unneeded
 
 linux_debug:
-	g++ $(source) -D DEBUG -std=$(cpp_standard) -Wall -Os -lSDL2 -lGL -ffunction-sections -fdata-sections -Wl,--gc-sections -o "$(executable)_debug"
-	strip -s -R .comment -R .gnu.version "$(executable)_debug" --strip-unneeded
+	@echo "Compilando version debug para Linux: $(TARGET_NAME)_debug"
+	g++ $(ALL_SOURCES) $(INCLUDES) -DDEBUG -DVERBOSE $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
 
 linux_release:
-# Remove data
-	rm -rdf "$(releaseFolder)"
+	@$(MAKE) pack_tool
+	@$(MAKE) resources.pack
+	@echo "Creando release para Linux - Version: $(VERSION)"
 
-# Create folders
-	mkdir -p "$(releaseFolder)"
+# Generate version.h from version.h.in
+	@echo "Generando version.h..."
+	@GIT_HASH=$$(git rev-parse --short=7 HEAD 2>/dev/null || echo "unknown"); \
+	sed "s/@GIT_HASH@/$$GIT_HASH/g" source/version.h.in > source/version.h
 
-# Copy data
-	cp -R data "$(releaseFolder)"
-	cp LICENSE "$(releaseFolder)"
-	cp README.md "$(releaseFolder)"
+# Elimina carpetas previas
+	$(RMDIR) "$(RELEASE_FOLDER)"
 
-# Delete data
-	rm -f "$(releaseFolder)/data/room/map.world"
-	rm -f "$(releaseFolder)/data/room/standard.tsx"
+# Crea la carpeta temporal para realizar el lanzamiento
+	$(MKDIR) "$(RELEASE_FOLDER)"
 
-# Build
-	g++ $(source) -std=$(cpp_standard) -Wall -Os -lSDL2 -lGL -ffunction-sections -fdata-sections -Wl,--gc-sections -o "$(releaseFolder)/$(executable)"
-	strip -s -R .comment -R .gnu.version "$(releaseFolder)/$(executable)" --strip-unneeded
+# Copia ficheros
+	cp resources.pack "$(RELEASE_FOLDER)"
+	cp LICENSE "$(RELEASE_FOLDER)"
+	cp README.md "$(RELEASE_FOLDER)"
+	cp gamecontrollerdb.txt "$(RELEASE_FOLDER)"
 
-# Pack files
-	rm -f "$(linuxRelease)"
-	cd "$(releaseFolder)" &&	tar -czvf "../$(linuxRelease)" *
+# Compila
+	g++ $(ALL_SOURCES) $(INCLUDES) -DRELEASE_BUILD $(CXXFLAGS) $(LDFLAGS) -o "$(RELEASE_FILE)"
+	strip -s -R .comment -R .gnu.version "$(RELEASE_FILE)" --strip-unneeded
 
-# Remove data
-	rm -rdf "$(releaseFolder)"
+# Empaqueta ficheros
+	$(RMFILE) "$(LINUX_RELEASE)"
+	tar -czvf "$(LINUX_RELEASE)" -C "$(RELEASE_FOLDER)" .
+	@echo "Release creado: $(LINUX_RELEASE)"
+
+# Elimina la carpeta temporal
+	$(RMDIR) "$(RELEASE_FOLDER)"
+
+# ==============================================================================
+# REGLAS ESPECIALES
+# ==============================================================================
+# Regla para mostrar la versión actual
+show_version:
+	@echo "Version actual: $(VERSION)"
+
+# Regla de ayuda
+help:
+	@echo "Makefile para JailDoctor's Dilemma"
+	@echo "Comandos disponibles:"
+	@echo "  windows          - Compilar para Windows"
+	@echo "  windows_debug    - Compilar debug para Windows"
+	@echo "  windows_release  - Crear release completo para Windows"
+	@echo "  linux            - Compilar para Linux"
+	@echo "  linux_debug      - Compilar debug para Linux"
+	@echo "  linux_release    - Crear release completo para Linux"
+	@echo "  macos            - Compilar para macOS"
+	@echo "  macos_debug      - Compilar debug para macOS"
+	@echo "  macos_release    - Crear release completo para macOS"
+	@echo "  pack_tool        - Compilar herramienta de empaquetado"
+	@echo "  resources.pack   - Generar pack de recursos desde data/"
+	@echo "  show_version     - Mostrar version actual ($(VERSION))"
+	@echo "  help             - Mostrar esta ayuda"
+
+FORCE:
+
+.PHONY: windows windows_debug windows_release macos macos_debug macos_release linux linux_debug linux_release pack_tool resources.pack show_version help

README.md

@@ -1,15 +1,19 @@
+<div align="center">
+  <img src="https://php.sustancia.synology.me/images/jdd/jaildoctors_dilemma_cover_web.png" width="600" alt="JailDoctor's Dilemma Cover">
+</div>
+
 # JailDoctor's Dilemma
 
 JailDoc és un Jailer. Als Jailers els agrada començar projectes. A ningú li agrada acabar-los. Els Jailers viuen a la Jail. A la Jail s'hi va a començar projectes. A la Jail s'hi va a ensenyar els projectes. A la Jail s'hi va a aprendre com començar nous projectes. A la Jail s'hi va a ajudar els companys a començar nous projectes.
 
-![JailDoctor's Dilemma - Pantalla de títol](https://php.sustancia.synology.me/images/jdd/jdd_title.png)
-
 JailDoc és un Jailer destacat entre els Jailers. Té més projectes començats que ningú i és qui més ajuda als altres a iniciar els seus.
 
 Però un dia, va passar una cosa inesperada. Algú va acabar un projecte. Algú va alliberar el *Puzzle Jail Facker*. Un autèntic desaprensiu.
 
 Això va fer que JailDoc prenguera una decisió: acabaria i lliuraria un dels seus projectes. Però, quin? *JailBattle*? *Sigmasuá*? *Calculín Doom*? Quin dilema! Finalment, es va arromangar i va decidir acabar i lliurar **tots** els seus projectes inacabats. Ho aconseguirà?
 
+<br clear="left">
+
 ---
 
 ## Jugabilitat
@@ -26,19 +30,25 @@ Quan hages recuperat la major part de les peces, dirigeix-te a la Jail per mostr
 
 El joc permet tant l'ús del teclat com d'un comandament. Les tecles per a jugar són les següents:
 
-- **Cursors**: Per moure's a l'esquerra o dreta i per saltar. Es poden modificar les tecles en el fitxer de configuració, triant entre aquestes opcions:
-    - O, P per moure's i Q per saltar.
-    - A, D per moure's i W per saltar.
+| Tecla | Acció |
+|-------|-------|
+| **←, →** | Moure's a l'esquerra o dreta |
+| **↑** | Saltar |
+| **Enter** | Eixir dels projectes |
+| **ESC** | Cancelar / Eixir del joc |
+| **F1** | Disminuir la mida de la finestra |
+| **F2** | Augmentar la mida de la finestra |
+| **F3** | Alternar pantalla completa |
+| **F4** | Activar/desactivar els shaders |
+| **F5** | Següent paleta de colors |
+| **F6** | Paleta de colors anterior |
+| **F7** | Activar/desactivar l'escalat exacte |
+| **F8** | Activar/desactivar la música |
+| **F9** | Activar/desactivar el marge de colors |
+| **F10** | Activar/desactivar VSync |
+| **F11** | Pausar el joc |
 
-- **Tecla M**: Activa o desactiva la música.
-- **Tecla P**: Pausa el joc.
-- **Tecla ESC**: Ix del joc si estàs jugant. Tanca el programa en qualsevol altra circumstància.
-- **Tecla F1**: Disminueix la mida de la finestra.
-- **Tecla F2**: Augmenta la mida de la finestra.
-- **Tecla F3**: Alterna entre el mode de pantalla completa i el mode finestra.
-- **Tecla F4**: Activa o desactiva els shaders
-- **Tecla F5**: Canvia la paleta de colors del joc.
-- **Tecla B**: Activa o desactiva el marge de colors en mode finestra.
+**Nota:** Les tecles de moviment (←, →, ↑) es poden redefinir des del menú del joc.
 
 ![JailDoctor's Dilemma - Gameplay](https://php.sustancia.synology.me/images/jdd/jdd_game2.png)
 
@@ -50,9 +60,9 @@ El programa guarda automàticament la configuració del mode de vídeo i les est
 
 - **Windows**: `C:\Users\<nom_d'usuari>\AppData\Roaming\jailgames\jaildoctors_dilemma`
 - **MacOS**: `~/Library/Application Support/jailgames/jaildoctors_dilemma`
-- **Linux**: `~/.jailgames/jaildoctors_dilemma`
+- **Linux**: `~/.config/jailgames/jaildoctors_dilemma`
 
-Dins de la carpeta es troba el fitxer de configuració `config.txt`, on es pot modificar la configuració per connectar-se al servei en línia, i els fitxers `stats.csv` i `stats_buffer.csv`, que contenen informació sobre les estadístiques del joc.
+Dins de la carpeta es troba el fitxer de configuració `config.yaml`, on es pot modificar la configuració per connectar-se al servei en línia, i els fitxers `stats.csv` i `stats_buffer.csv`, que contenen informació sobre les estadístiques del joc.
 
 ---
 

config/assets.yaml

@@ -0,0 +1,592 @@
+# JailDoctor's Dilemma - Asset Configuration
+# Variables: ${PREFIX}, ${SYSTEM_FOLDER}
+
+assets:
+  # FONTS
+  fonts:
+    - type: BITMAP
+      path: ${PREFIX}/data/font/smb2.gif
+    - type: FONT
+      path: ${PREFIX}/data/font/smb2.txt
+    - type: BITMAP
+      path: ${PREFIX}/data/font/aseprite.gif
+    - type: FONT
+      path: ${PREFIX}/data/font/aseprite.txt
+    - type: BITMAP
+      path: ${PREFIX}/data/font/gauntlet.gif
+    - type: FONT
+      path: ${PREFIX}/data/font/gauntlet.txt
+    - type: BITMAP
+      path: ${PREFIX}/data/font/subatomic.gif
+    - type: FONT
+      path: ${PREFIX}/data/font/subatomic.txt
+    - type: BITMAP
+      path: ${PREFIX}/data/font/8bithud.gif
+    - type: FONT
+      path: ${PREFIX}/data/font/8bithud.txt
+
+  # PALETTES
+  palettes:
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/zx-spectrum.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/zx-spectrum-adjusted.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/zxarne-5-2.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/black-and-white.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/green-phosphor.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/orange-screen.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/ruzx-spectrum.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/ruzx-spectrum-revision-2.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/pico-8.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/sweetie-16.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/island-joy-16.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/lost-century.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/na16.pal
+    - type: PALETTE
+      path: ${PREFIX}/data/palette/steam-lords.pal
+
+  # SHADERS
+  shaders:
+    - type: DATA
+      path: ${PREFIX}/data/shaders/crtpi_vertex.glsl
+    - type: DATA
+      path: ${PREFIX}/data/shaders/crtpi_fragment.glsl
+    - type: DATA
+      path: ${PREFIX}/data/shaders/crtpi_vertex_es.glsl
+    - type: DATA
+      path: ${PREFIX}/data/shaders/crtpi_fragment_es.glsl
+
+  # INPUT
+  input:
+    - type: DATA
+      path: ${PREFIX}/gamecontrollerdb.txt
+
+  # SYSTEM
+  system:
+    - type: DATA
+      path: ${SYSTEM_FOLDER}/config.yaml
+      required: false
+      absolute: true
+    - type: DATA
+      path: ${SYSTEM_FOLDER}/stats_buffer.csv
+      required: false
+      absolute: true
+    - type: DATA
+      path: ${SYSTEM_FOLDER}/stats.csv
+      required: false
+      absolute: true
+    - type: DATA
+      path: ${SYSTEM_FOLDER}/cheevos.bin
+      required: false
+      absolute: true
+
+  # ROOMS
+  rooms:
+    - type: ROOM
+      path: ${PREFIX}/data/room/01.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/02.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/03.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/04.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/05.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/06.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/07.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/08.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/09.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/10.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/11.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/12.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/13.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/14.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/15.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/16.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/17.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/18.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/19.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/20.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/21.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/22.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/23.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/24.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/25.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/26.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/27.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/28.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/29.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/30.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/31.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/32.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/33.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/34.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/35.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/36.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/37.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/38.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/39.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/40.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/41.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/42.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/43.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/44.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/45.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/46.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/47.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/48.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/49.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/50.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/51.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/52.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/53.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/54.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/55.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/56.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/57.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/58.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/59.yaml
+    - type: ROOM
+      path: ${PREFIX}/data/room/60.yaml
+
+  # TILESETS
+  tilesets:
+    - type: BITMAP
+      path: ${PREFIX}/data/tilesets/standard.gif
+
+  # ENEMIES
+  enemies:
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/abad_bell.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/abad_bell.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/abad.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/abad.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/amstrad_cs.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/amstrad_cs.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/flying_arounder.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/flying_arounder.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/stopped_arounder.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/stopped_arounder.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/walking_arounder.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/walking_arounder.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/arounders_door.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/arounders_door.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/arounders_machine.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/arounders_machine.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/bat.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/bat.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/batman_bell.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/batman_bell.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/batman_fire.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/batman_fire.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/batman.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/batman.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/bell.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/bell.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/bin.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/bin.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/bird.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/bird.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/breakout.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/breakout.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/bry.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/bry.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/chip.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/chip.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/code.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/code.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/congo.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/congo.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/crosshair.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/crosshair.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/demon.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/demon.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/dimallas.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/dimallas.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/floppy.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/floppy.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/dong.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/dong.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/guitar.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/guitar.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/heavy.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/heavy.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/jailer1.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/jailer1.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/jailer2.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/jailer2.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/jailer3.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/jailer3.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/jailbattle_alien.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/jailbattle_alien.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/jailbattle_human.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/jailbattle_human.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/jeannine.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/jeannine.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/lamp.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/lamp.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/lord_abad.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/lord_abad.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/matatunos.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/matatunos.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/mummy.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/mummy.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/paco.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/paco.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/elsa.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/elsa.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/qvoid.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/qvoid.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/robot.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/robot.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/sam.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/sam.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/shock.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/shock.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/sigmasua.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/sigmasua.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/spark.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/spark.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/special/aerojailer.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/special/aerojailer.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/special/arounder.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/special/arounder.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/special/pepe_rosita_job.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/special/pepe_rosita_job.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/special/shooting_star.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/special/shooting_star.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/spider.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/spider.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/tree_thing.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/tree_thing.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/tuno.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/tuno.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/tv_panel.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/tv_panel.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/tv.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/tv.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/upv_student.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/upv_student.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/wave.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/wave.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/enemies/z80.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/enemies/z80.gif
+
+  # PLAYER
+  player:
+    - type: BITMAP
+      path: ${PREFIX}/data/player/player.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/player/player.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/player/player2.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/player/player2.yaml
+    - type: BITMAP
+      path: ${PREFIX}/data/player/player_game_over.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/player/player_game_over.yaml
+
+  # ITEMS
+  items:
+    - type: BITMAP
+      path: ${PREFIX}/data/items/items.gif
+
+  # MUSIC
+  music:
+    - type: MUSIC
+      path: ${PREFIX}/data/music/title.ogg
+    - type: MUSIC
+      path: ${PREFIX}/data/music/game.ogg
+    - type: MUSIC
+      path: ${PREFIX}/data/music/loading_data1.ogg
+    - type: MUSIC
+      path: ${PREFIX}/data/music/loading_data2.ogg
+    - type: MUSIC
+      path: ${PREFIX}/data/music/loading_header.ogg
+    - type: MUSIC
+      path: ${PREFIX}/data/music/loading_screen_color.ogg
+    - type: MUSIC
+      path: ${PREFIX}/data/music/loading_screen_data.ogg
+    - type: MUSIC
+      path: ${PREFIX}/data/music/ending1.ogg
+    - type: MUSIC
+      path: ${PREFIX}/data/music/ending2.ogg
+    - type: MUSIC
+      path: ${PREFIX}/data/music/game_over.ogg
+
+  # SOUNDS
+  sounds:
+    - type: SOUND
+      path: ${PREFIX}/data/sound/item.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/death.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/notify.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump1.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump2.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump3.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump4.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump5.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump6.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump7.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump8.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump9.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump10.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump11.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump12.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump13.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump14.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump15.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump16.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump17.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump18.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump19.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump20.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump21.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump22.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump23.wav
+    - type: SOUND
+      path: ${PREFIX}/data/sound/jump24.wav
+
+  # LOGO
+  logo:
+    - type: BITMAP
+      path: ${PREFIX}/data/logo/jailgames.gif
+    - type: BITMAP
+      path: ${PREFIX}/data/logo/since_1998.gif
+
+  # LOADING
+  loading:
+    - type: BITMAP
+      path: ${PREFIX}/data/loading/loading_screen_bn.gif
+    - type: BITMAP
+      path: ${PREFIX}/data/loading/loading_screen_color.gif
+    - type: BITMAP
+      path: ${PREFIX}/data/loading/program_jaildoc.gif
+
+  # TITLE
+  title:
+    - type: BITMAP
+      path: ${PREFIX}/data/title/title_logo.gif
+
+  # ENDING
+  ending:
+    - type: BITMAP
+      path: ${PREFIX}/data/ending/ending1.gif
+    - type: BITMAP
+      path: ${PREFIX}/data/ending/ending2.gif
+    - type: BITMAP
+      path: ${PREFIX}/data/ending/ending3.gif
+    - type: BITMAP
+      path: ${PREFIX}/data/ending/ending4.gif
+    - type: BITMAP
+      path: ${PREFIX}/data/ending/ending5.gif
+
+  # CREDITS
+  credits:
+    - type: BITMAP
+      path: ${PREFIX}/data/credits/shine.gif
+    - type: ANIMATION
+      path: ${PREFIX}/data/credits/shine.yaml

data/credits/shine.ani

@@ -1,9 +0,0 @@
-frame_width=8
-frame_height=8
-
-[animation]
-name=default
-speed=6
-loop=-1
-frames=0,1,2,3,4,5,6,7
-[/animation]

data/credits/shine.yaml

@@ -0,0 +1,10 @@
+# shine animation
+tileSetFile: shine.gif
+frameWidth: 8
+frameHeight: 8
+
+animations:
+  - name: default
+    speed: 0.1
+    loop: -1
+    frames: [0, 1, 2, 3, 4, 5, 6, 7]

data/enemies/abad.ani

@@ -1,9 +0,0 @@
-frame_width=8
-frame_height=16
-
-[animation]
-name=default
-speed=8
-loop=0
-frames=0,1,2
-[/animation]

data/enemies/abad.yaml

@@ -0,0 +1,10 @@
+# abad animation
+tileSetFile: abad.gif
+frameWidth: 8
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.1333
+    loop: 0
+    frames: [0, 1, 2]

data/enemies/abad_bell.ani

@@ -1,9 +0,0 @@
-frame_width=16
-frame_height=16
-
-[animation]
-name=default
-speed=4
-loop=0
-frames=0,1,2,3,4,5,6,7,8,9
-[/animation]

data/enemies/abad_bell.yaml

@@ -0,0 +1,10 @@
+# abad_bell animation
+tileSetFile: abad_bell.gif
+frameWidth: 16
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.0667
+    loop: 0
+    frames: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

data/enemies/amstrad_cs.ani

@@ -1,9 +0,0 @@
-frame_width=8
-frame_height=8
-
-[animation]
-name=default
-speed=4
-loop=0
-frames=0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
-[/animation]

data/enemies/amstrad_cs.yaml

@@ -0,0 +1,10 @@
+# amstrad_cs animation
+tileSetFile: amstrad_cs.gif
+frameWidth: 8
+frameHeight: 8
+
+animations:
+  - name: default
+    speed: 0.0667
+    loop: 0
+    frames: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255]

data/enemies/arounders_door.ani

@@ -1,9 +0,0 @@
-frame_width=16
-frame_height=16
-
-[animation]
-name=default
-speed=8
-loop=0
-frames=0,1,2,3,3,3,3,3,3,3,3,3,3,3,3,2,1,0,0,0
-[/animation]

data/enemies/arounders_door.yaml

@@ -0,0 +1,10 @@
+# arounders_door animation
+tileSetFile: arounders_door.gif
+frameWidth: 16
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.1333
+    loop: 0
+    frames: [0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, 0, 0]

data/enemies/arounders_machine.ani

@@ -1,9 +0,0 @@
-frame_width=16
-frame_height=16
-
-[animation]
-name=default
-speed=4
-loop=0
-frames=0,1,2,3
-[/animation]

data/enemies/arounders_machine.yaml

@@ -0,0 +1,10 @@
+# arounders_machine animation
+tileSetFile: arounders_machine.gif
+frameWidth: 16
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.0667
+    loop: 0
+    frames: [0, 1, 2, 3]

data/enemies/bat.ani

@@ -1,9 +0,0 @@
-frame_width=9
-frame_height=7
-
-[animation]
-name=default
-speed=3
-loop=0
-frames=0,1
-[/animation]

data/enemies/bat.yaml

@@ -0,0 +1,10 @@
+# bat animation
+tileSetFile: bat.gif
+frameWidth: 9
+frameHeight: 7
+
+animations:
+  - name: default
+    speed: 0.05
+    loop: 0
+    frames: [0, 1]

data/enemies/batman.ani

@@ -1,9 +0,0 @@
-frame_width=8
-frame_height=16
-
-[animation]
-name=default
-speed=8
-loop=0
-frames=0,1,2,3
-[/animation]

data/enemies/batman.yaml

@@ -0,0 +1,10 @@
+# batman animation
+tileSetFile: batman.gif
+frameWidth: 8
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.1333
+    loop: 0
+    frames: [0, 1, 2, 3]

data/enemies/batman_bell.ani

@@ -1,9 +0,0 @@
-frame_width=16
-frame_height=16
-
-[animation]
-name=default
-speed=6
-loop=0
-frames=0,1,2,3,4,5
-[/animation]

data/enemies/batman_bell.yaml

@@ -0,0 +1,10 @@
+# batman_bell animation
+tileSetFile: batman_bell.gif
+frameWidth: 16
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.1
+    loop: 0
+    frames: [0, 1, 2, 3, 4, 5]

data/enemies/batman_fire.ani

@@ -1,9 +0,0 @@
-frame_width=16
-frame_height=16
-
-[animation]
-name=default
-speed=4
-loop=0
-frames=0,1,2,3
-[/animation]

data/enemies/batman_fire.yaml

@@ -0,0 +1,10 @@
+# batman_fire animation
+tileSetFile: batman_fire.gif
+frameWidth: 16
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.0667
+    loop: 0
+    frames: [0, 1, 2, 3]

data/enemies/bell.ani

@@ -1,9 +0,0 @@
-frame_width=16
-frame_height=16
-
-[animation]
-name=default
-speed=6
-loop=0
-frames=0,1,2,3,4,5,6,7,8,9,10,11
-[/animation]

data/enemies/bell.yaml

@@ -0,0 +1,10 @@
+# bell animation
+tileSetFile: bell.gif
+frameWidth: 16
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.1
+    loop: 0
+    frames: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

data/enemies/bin.ani

@@ -1,9 +0,0 @@
-frame_width=16
-frame_height=8
-
-[animation]
-name=default
-speed=10
-loop=0
-frames=0,1,2,3,4
-[/animation]

data/enemies/bin.yaml

@@ -0,0 +1,10 @@
+# bin animation
+tileSetFile: bin.gif
+frameWidth: 16
+frameHeight: 8
+
+animations:
+  - name: default
+    speed: 0.1667
+    loop: 0
+    frames: [0, 1, 2, 3, 4]

data/enemies/bird.ani

@@ -1,9 +0,0 @@
-frame_width=16
-frame_height=16
-
-[animation]
-name=default
-speed=8
-loop=0
-frames=0,1,2,3
-[/animation]

data/enemies/bird.yaml

@@ -0,0 +1,10 @@
+# bird animation
+tileSetFile: bird.gif
+frameWidth: 16
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.1333
+    loop: 0
+    frames: [0, 1, 2, 3]

data/enemies/breakout.ani

@@ -1,9 +0,0 @@
-frame_width=24
-frame_height=32
-
-[animation]
-name=default
-speed=6
-loop=0
-frames=0,1,2,3,4,5,6,7,6,5,4,3,2,1
-[/animation]

data/enemies/breakout.yaml

@@ -0,0 +1,10 @@
+# breakout animation
+tileSetFile: breakout.gif
+frameWidth: 24
+frameHeight: 32
+
+animations:
+  - name: default
+    speed: 0.1
+    loop: 0
+    frames: [0, 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1]

data/enemies/bry.ani

@@ -1,9 +0,0 @@
-frame_width=10
-frame_height=16
-
-[animation]
-name=default
-speed=6
-loop=0
-frames=0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3,4,5,4,5,4,5,4,5,4,5,4,5,4,5,4,5,4,5,4,5,4,5,4,5
-[/animation]

data/enemies/bry.yaml

@@ -0,0 +1,10 @@
+# bry animation
+tileSetFile: bry.gif
+frameWidth: 10
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.1
+    loop: 0
+    frames: [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5]

data/enemies/chip.ani

@@ -1,9 +0,0 @@
-frame_width=8
-frame_height=16
-
-[animation]
-name=default
-speed=8
-loop=0
-frames=0,1,2,3
-[/animation]

data/enemies/chip.yaml

@@ -0,0 +1,10 @@
+# chip animation
+tileSetFile: chip.gif
+frameWidth: 8
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.1333
+    loop: 0
+    frames: [0, 1, 2, 3]

data/enemies/code.ani

@@ -1,9 +0,0 @@
-frame_width=16
-frame_height=16
-
-[animation]
-name=default
-speed=6
-loop=0
-frames=0,1,2,3
-[/animation]

data/enemies/code.yaml

@@ -0,0 +1,10 @@
+# code animation
+tileSetFile: code.gif
+frameWidth: 16
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.1
+    loop: 0
+    frames: [0, 1, 2, 3]

data/enemies/congo.ani

@@ -1,9 +0,0 @@
-frame_width=8
-frame_height=16
-
-[animation]
-name=default
-speed=6
-loop=0
-frames=0,1,2,3
-[/animation]

data/enemies/congo.yaml

@@ -0,0 +1,10 @@
+# congo animation
+tileSetFile: congo.gif
+frameWidth: 8
+frameHeight: 16
+
+animations:
+  - name: default
+    speed: 0.1
+    loop: 0
+    frames: [0, 1, 2, 3]