jaildesigner-jailgames/jaildoctors_dilemma
1
0
Fork 2
Code Issues 1 Pull Requests Projects Releases 20 Wiki Activity

eliminat el checkFiles inicial que a jaildoc li molestava

Browse Source
This commit is contained in:
Sergio
2025-11-21 13:34:20 +01:00
parent b475c4d818
commit 1fed8f63bd
9 changed files with 233 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.claude/settings.local.json
View File

@@ -10,7 +10,10 @@
"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(done)",
"Bash(Xvfb:*)",
"Bash(chmod:*)",
"Bash(timeout:*)"
],
"deny": [],
"ask": []

93
CLAUDE.md
View File

@@ -55,6 +55,46 @@ cmake --build build --clean-first
**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:
@@ -306,8 +346,8 @@ class Screen {
- `Screen` - Rendering, window management, palette/shader effects
- `Input` - Keyboard & gamepad input binding and checking
- `Audio` - Music and sound effect playback
- `Resource` - Asset loading, caching, streaming
- `Asset` - Asset path registry and verification
- `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
@@ -413,12 +453,14 @@ struct AnimationData {
main()
↓
Director::Director() [Initialization]
├─ Options::init() - Load game configuration
├─ Asset::init() - Register asset paths
├─ Screen::init() - Create window, SDL renderer
├─ 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::init() - Load all game resources
├─ 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]
@@ -433,11 +475,11 @@ Director::run() [Main loop]
Director::~Director() [Cleanup]
├─ Options::saveToFile() - Save game settings
├─ Resource::destroy()
├─ Resource::Cache::destroy()
├─ Audio::destroy()
├─ Input::destroy()
├─ Screen::destroy()
└─ Asset::destroy()
└─ Resource::List::destroy()
```
### 4.2 Game Scene Flow (Core Gameplay Loop)
@@ -468,24 +510,27 @@ Game::run() {
```
Director::setFileList()
├─ Asset::loadFromFile(config_path, PREFIX, system_folder_)
│ ├─ Read config/assets.yaml - Parse text configuration file
│ ├─ Parse each line: TYPE|PATH|OPTIONS - Extract asset information
│ ├─ Replace variables (${PREFIX}, ${SYSTEM_FOLDER})
│ └─ Store in unordered_map (O(1) lookup) - Fast asset path retrieval
└─ Asset::check() - Verify required files exist
└─ 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::init() - Loads all resources
├─ loadSounds() - WAV files
├─ loadMusics() - OGG files
├─ loadSurfaces() - GIF/PNG images
├─ loadAnimations() - .ani animation definitions
├─ loadTileMaps() - .room tilemap data
└─ loadRooms() - Room metadata
└─ 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::get*(name) - Return cached resource
└─ Resource::Cache::get*(name) - Return cached resource
```
### 4.4 Input Flow
@@ -653,8 +698,8 @@ Achievements trigger notifications on unlock.
| `Screen` | Rendering, window, palette management | Singleton |
| `Input` | Keyboard & gamepad input | Singleton |
| `Audio` | Music and SFX playback | Singleton |
| `Resource` | Asset caching and loading | Singleton |
| `Asset` | Asset path registry from config/assets.yaml, O(1) lookups, variable substitution | 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 |

51
run_headless.sh Executable file
View File

@@ -0,0 +1,51 @@
#!/bin/bash
# Script para ejecutar JailDoctor's Dilemma en modo headless (sin pantalla)
# Usa Xvfb (X Virtual Framebuffer) para simular un display
# Configuración
GAME_EXECUTABLE="./jaildoctors_dilemma"
DISPLAY_SIZE="1280x720x24" # Resolución y profundidad de color
# Colores para output
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color
echo -e "${GREEN}=== JailDoctor's Dilemma - Modo Headless ===${NC}"
echo ""
# Verificar que Xvfb está instalado
if ! command -v xvfb-run &> /dev/null; then
echo -e "${YELLOW}ERROR: Xvfb no está instalado${NC}"
echo "Instálalo con: sudo apt-get install xvfb"
exit 1
fi
# Verificar que el ejecutable existe
if [ ! -f "$GAME_EXECUTABLE" ]; then
echo -e "${YELLOW}ERROR: No se encuentra el ejecutable $GAME_EXECUTABLE${NC}"
echo "Compila el juego primero con: cmake --build build"
exit 1
fi
echo "Iniciando juego con Xvfb..."
echo "Display virtual: $DISPLAY_SIZE"
echo ""
echo -e "${YELLOW}Nota: El juego está corriendo. Presiona Ctrl+C para detenerlo.${NC}"
echo ""
# Ejecutar el juego con Xvfb
# Opciones:
# -a: Selecciona automáticamente un número de display disponible
# -s: Configura el servidor X (resolución y profundidad)
xvfb-run -a -s "-screen 0 ${DISPLAY_SIZE}" "$GAME_EXECUTABLE" "$@"
EXIT_CODE=$?
echo ""
if [ $EXIT_CODE -eq 0 ]; then
echo -e "${GREEN}Juego finalizado correctamente${NC}"
else
echo -e "${YELLOW}Juego finalizado con código de salida: $EXIT_CODE${NC}"
fi
exit $EXIT_CODE

149
source/core/resources/resource_cache.cpp
View File

@@ -176,6 +176,15 @@ auto Cache::getRooms() -> std::vector<RoomResource>& {
return rooms_;
}
// Helper para lanzar errores de carga con formato consistente
[[noreturn]] void Cache::throwLoadError(const std::string& asset_type, const std::string& file_path, const std::exception& e) {
std::cerr << "\n[ ERROR ] Failed to load " << asset_type << ": " << getFileName(file_path) << '\n';
std::cerr << "[ ERROR ] Path: " << file_path << '\n';
std::cerr << "[ ERROR ] Reason: " << e.what() << '\n';
std::cerr << "[ ERROR ] Check config/assets.yaml configuration\n";
throw;
}
// Carga los sonidos
void Cache::loadSounds() {
std::cout << "\n>> SOUND FILES" << '\n';
@@ -183,23 +192,31 @@ void Cache::loadSounds() {
sounds_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
JA_Sound_t* sound = nullptr;
try {
auto name = getFileName(l);
JA_Sound_t* sound = nullptr;
// Try loading from resource pack first
auto audio_data = Helper::loadFile(l);
if (!audio_data.empty()) {
sound = JA_LoadSound(audio_data.data(), static_cast<Uint32>(audio_data.size()));
// Try loading from resource pack first
auto audio_data = Helper::loadFile(l);
if (!audio_data.empty()) {
sound = JA_LoadSound(audio_data.data(), static_cast<Uint32>(audio_data.size()));
}
// Fallback to file path if memory loading failed
if (sound == nullptr) {
sound = JA_LoadSound(l.c_str());
}
if (sound == nullptr) {
throw std::runtime_error("Failed to decode audio file");
}
sounds_.emplace_back(SoundResource{.name = name, .sound = sound});
printWithDots("Sound : ", name, "[ LOADED ]");
updateLoadingProgress();
} catch (const std::exception& e) {
throwLoadError("SOUND", l, e);
}
// Fallback to file path if memory loading failed
if (sound == nullptr) {
sound = JA_LoadSound(l.c_str());
}
sounds_.emplace_back(SoundResource{.name = name, .sound = sound});
printWithDots("Sound : ", name, "[ LOADED ]");
updateLoadingProgress();
}
}
@@ -210,23 +227,31 @@ void Cache::loadMusics() {
musics_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
JA_Music_t* music = nullptr;
try {
auto name = getFileName(l);
JA_Music_t* music = nullptr;
// Try loading from resource pack first
auto audio_data = Helper::loadFile(l);
if (!audio_data.empty()) {
music = JA_LoadMusic(audio_data.data(), static_cast<Uint32>(audio_data.size()));
// Try loading from resource pack first
auto audio_data = Helper::loadFile(l);
if (!audio_data.empty()) {
music = JA_LoadMusic(audio_data.data(), static_cast<Uint32>(audio_data.size()));
}
// Fallback to file path if memory loading failed
if (music == nullptr) {
music = JA_LoadMusic(l.c_str());
}
if (music == nullptr) {
throw std::runtime_error("Failed to decode music file");
}
musics_.emplace_back(MusicResource{.name = name, .music = music});
printWithDots("Music : ", name, "[ LOADED ]");
updateLoadingProgress(1);
} catch (const std::exception& e) {
throwLoadError("MUSIC", l, e);
}
// Fallback to file path if memory loading failed
if (music == nullptr) {
music = JA_LoadMusic(l.c_str());
}
musics_.emplace_back(MusicResource{.name = name, .music = music});
printWithDots("Music : ", name, "[ LOADED ]");
updateLoadingProgress(1);
}
}
@@ -237,10 +262,14 @@ void Cache::loadSurfaces() {
surfaces_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
surfaces_.emplace_back(SurfaceResource{.name = name, .surface = std::make_shared<Surface>(l)});
surfaces_.back().surface->setTransparentColor(0);
updateLoadingProgress();
try {
auto name = getFileName(l);
surfaces_.emplace_back(SurfaceResource{.name = name, .surface = std::make_shared<Surface>(l)});
surfaces_.back().surface->setTransparentColor(0);
updateLoadingProgress();
} catch (const std::exception& e) {
throwLoadError("BITMAP", l, e);
}
}
// Reconfigura el color transparente de algunas surfaces
@@ -260,9 +289,13 @@ void Cache::loadPalettes() {
palettes_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
palettes_.emplace_back(ResourcePalette{.name = name, .palette = readPalFile(l)});
updateLoadingProgress();
try {
auto name = getFileName(l);
palettes_.emplace_back(ResourcePalette{.name = name, .palette = readPalFile(l)});
updateLoadingProgress();
} catch (const std::exception& e) {
throwLoadError("PALETTE", l, e);
}
}
}
@@ -273,9 +306,13 @@ void Cache::loadTextFiles() {
text_files_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
text_files_.emplace_back(TextFileResource{.name = name, .text_file = Text::loadTextFile(l)});
updateLoadingProgress();
try {
auto name = getFileName(l);
text_files_.emplace_back(TextFileResource{.name = name, .text_file = Text::loadTextFile(l)});
updateLoadingProgress();
} catch (const std::exception& e) {
throwLoadError("FONT", l, e);
}
}
}
@@ -286,14 +323,22 @@ void Cache::loadAnimations() {
animations_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
try {
auto name = getFileName(l);
// Cargar bytes del archivo YAML sin parsear (carga lazy)
auto yaml_bytes = Helper::loadFile(l);
// Cargar bytes del archivo YAML sin parsear (carga lazy)
auto yaml_bytes = Helper::loadFile(l);
animations_.emplace_back(AnimationResource{.name = name, .yaml_data = yaml_bytes});
printWithDots("Animation : ", name, "[ LOADED ]");
updateLoadingProgress();
if (yaml_bytes.empty()) {
throw std::runtime_error("File is empty or could not be loaded");
}
animations_.emplace_back(AnimationResource{.name = name, .yaml_data = yaml_bytes});
printWithDots("Animation : ", name, "[ LOADED ]");
updateLoadingProgress();
} catch (const std::exception& e) {
throwLoadError("ANIMATION", l, e);
}
}
}
@@ -304,10 +349,14 @@ void Cache::loadRooms() {
rooms_.clear();
for (const auto& l : list) {
auto name = getFileName(l);
rooms_.emplace_back(RoomResource{.name = name, .room = std::make_shared<Room::Data>(Room::loadYAML(l))});
printWithDots("Room : ", name, "[ LOADED ]");
updateLoadingProgress();
try {
auto name = getFileName(l);
rooms_.emplace_back(RoomResource{.name = name, .room = std::make_shared<Room::Data>(Room::loadYAML(l))});
printWithDots("Room : ", name, "[ LOADED ]");
updateLoadingProgress();
} catch (const std::exception& e) {
throwLoadError("ROOM", l, e);
}
}
}

3
source/core/resources/resource_cache.hpp
View File

@@ -66,6 +66,9 @@ class Cache {
static void checkEvents();
void updateLoadingProgress(int steps = 5);
// Helper para mensajes de error de carga
[[noreturn]] static void throwLoadError(const std::string& asset_type, const std::string& file_path, const std::exception& e);
// Constructor y destructor
Cache();
~Cache() = default;

55
source/core/resources/resource_list.cpp
View File

@@ -200,61 +200,6 @@ auto List::exists(const std::string& filename) const -> bool {
return file_list_.find(filename) != file_list_.end();
}
// Comprueba que existen todos los elementos
auto List::check() const -> bool {
bool success = true;
std::cout << "\n** CHECKING FILES" << '\n';
// Agrupar por tipo para mostrar organizado
std::unordered_map<Type, std::vector<const Item*>> by_type;
for (const auto& [filename, item] : file_list_) {
if (item.required) {
by_type[item.type].push_back(&item);
}
}
// Verificar por tipo
for (int type = 0; type < static_cast<int>(Type::SIZE); ++type) {
Type asset_type = static_cast<Type>(type);
if (by_type.find(asset_type) != by_type.end()) {
std::cout << "\n>> " << getTypeName(asset_type) << " FILES" << '\n';
bool type_success = true;
for (const auto* item : by_type[asset_type]) {
if (!checkFile(item->file)) {
success = false;
type_success = false;
}
}
if (type_success) {
std::cout << " All files are OK." << '\n';
}
}
}
// Resultado
std::cout << (success ? "\n** CHECKING FILES COMPLETED.\n" : "\n** CHECKING FILES FAILED.\n") << '\n';
return success;
}
// Comprueba que existe un fichero
auto List::checkFile(const std::string& path) -> bool {
std::ifstream file(path);
bool success = file.good();
file.close();
if (!success) {
printWithDots("Checking file : ", getFileName(path), "[ ERROR ]");
}
return success;
}
// Parsea string a Type
auto List::parseAssetType(const std::string& type_str) -> Type {
if (type_str == "DATA") {

2
source/core/resources/resource_list.hpp
View File

@@ -37,7 +37,6 @@ class List {
void loadFromString(const std::string& config_content, const std::string& prefix = "", const std::string& system_folder = ""); // Para cargar desde pack (release)
[[nodiscard]] auto get(const std::string& filename) const -> std::string; // Obtiene la ruta completa
[[nodiscard]] auto loadData(const std::string& filename) const -> std::vector<uint8_t>; // Carga datos del archivo
[[nodiscard]] auto check() const -> bool;
[[nodiscard]] auto getListByType(Type type) const -> std::vector<std::string>;
[[nodiscard]] auto exists(const std::string& filename) const -> bool; // Verifica si un asset existe
@@ -59,7 +58,6 @@ class List {
std::string executable_path_; // Ruta del ejecutable
// --- Métodos internos ---
[[nodiscard]] static auto checkFile(const std::string& path) -> bool; // Verifica si un archivo existe
[[nodiscard]] static auto getTypeName(Type type) -> std::string; // Obtiene el nombre del tipo
[[nodiscard]] static auto parseAssetType(const std::string& type_str) -> Type; // Convierte string a tipo
void addToMap(const std::string& file_path, Type type, bool required, bool absolute); // Añade archivo al mapa

15
source/core/system/director.cpp
View File

@@ -107,10 +107,9 @@ Director::Director(std::vector<std::string> const& args) {
// 1. Initialize Asset system from filesystem
Resource::List::init(executable_path_);
// 2. Load and verify assets from disk
if (!setFileList()) {
exit(EXIT_FAILURE);
}
// 2. Load asset configuration from disk
// Note: Asset verification happens during Resource::Cache::load()
setFileList();
// 3. Initialize resource pack system (optional, with fallback)
std::cout << "Initializing resource pack (development mode): " << pack_path << '\n';
@@ -259,8 +258,8 @@ void Director::createSystemFolder(const std::string& folder) {
}
}
// Crea el indice de ficheros
auto Director::setFileList() -> bool {
// Carga la configuración de assets desde assets.yaml
void Director::setFileList() {
// Determinar el prefijo de ruta según la plataforma
#ifdef MACOS_BUNDLE
const std::string PREFIX = "/../Resources";
@@ -272,10 +271,8 @@ auto Director::setFileList() -> bool {
std::string config_path = executable_path_ + PREFIX + "/config/assets.yaml";
// Cargar todos los assets desde el archivo de configuración
// La verificación de existencia de archivos se realiza durante Resource::Cache::load()
Resource::List::get()->loadFromFile(config_path, PREFIX, system_folder_);
// Verificar que todos los assets requeridos existen
return Resource::List::get()->check();
}
// Ejecuta la seccion de juego con el logo

2
source/core/system/director.hpp
View File

@@ -19,7 +19,7 @@ class Director {
// --- Funciones ---
void createSystemFolder(const std::string& folder); // Crea la carpeta del sistema donde guardar datos
auto setFileList() -> bool; // Crea el indice de ficheros
void setFileList(); // Carga la configuración de assets desde assets.yaml
static void runLogo(); // Ejecuta la seccion de juego con el logo
static void runLoadingScreen(); // Ejecuta la seccion de juego de la pantalla de carga
static void runTitle(); // Ejecuta la seccion de juego con el titulo y los menus