jaildesigner-jailgames/coffee_crisis_arcade_edition
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 13 Wiki Activity

Merge branch 'main' of https://gitea.sustancia.synology.me/JailDesigner/coffee_crisis_arcade_edition

Browse Source
This commit is contained in:
Sergio
2025-08-24 10:51:10 +02:00
parent 26ed479306 32e9da55ef
commit dfdb679054
46 changed files with 1386 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@@ -28,6 +28,9 @@ set(APP_SOURCES
source/main.cpp
source/param.cpp
source/resource.cpp
source/resource_helper.cpp
source/resource_loader.cpp
source/resource_pack.cpp
source/screen.cpp
source/text.cpp
source/writer.cpp

22
LICENSE
View File

@@ -1 +1,21 @@
GNU General Public License v3.0 only
Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License
Copyright (c) 2025 Coffee Crisis Arcade Edition
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.

25
Makefile
View File

@@ -71,6 +71,9 @@ APP_SOURCES := \
source/path_sprite.cpp \
source/player.cpp \
source/resource.cpp \
source/resource_helper.cpp \
source/resource_loader.cpp \
source/resource_pack.cpp \
source/scoreboard.cpp \
source/screen.cpp \
source/sections/credits.cpp \
@@ -104,7 +107,7 @@ INCLUDES := -Isource -Isource/external
# Variables según el sistema operativo
ifeq ($(OS),Windows_NT)
FixPath = $(subst /,\\,$1)
CXXFLAGS := -std=c++20 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -Wl,-subsystem,windows -DWINDOWS_BUILD
CXXFLAGS := -std=c++20 -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -static-libstdc++ -static-libgcc -Wl,-Bstatic -lpthread -Wl,-Bdynamic -Wl,-subsystem,windows -DWINDOWS_BUILD
CXXFLAGS_DEBUG := -std=c++20 -Wall -g -D_DEBUG -DWINDOWS_BUILD
LDFLAGS := -lmingw32 -lws2_32 -lSDL3 -lopengl32
RM := del /Q
@@ -158,8 +161,9 @@ windows_release:
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}
# Copia la carpeta 'data'
powershell Copy-Item -Path "data" -Destination "$(RELEASE_FOLDER)" -recurse -Force
# Copia la carpeta 'config' y el archivo 'resources.pack'
powershell Copy-Item -Path "config" -Destination "$(RELEASE_FOLDER)" -recurse -Force
powershell Copy-Item -Path "resources.pack" -Destination "$(RELEASE_FOLDER)"
# Copia los ficheros que estan en la raíz del proyecto
powershell Copy-Item "LICENSE" -Destination "$(RELEASE_FOLDER)"
@@ -203,7 +207,8 @@ macos_release:
$(MKDIR) Frameworks
# Copia carpetas y ficheros
cp -R data "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
cp -R config "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
cp resources.pack "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
cp -R release/frameworks/SDL3.xcframework "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks"
cp -R release/frameworks/SDL3.xcframework Frameworks
cp release/*.icns "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
@@ -262,7 +267,8 @@ linux_release:
$(MKDIR) "$(RELEASE_FOLDER)"
# Copia ficheros
cp -R data "$(RELEASE_FOLDER)"
cp -R config "$(RELEASE_FOLDER)"
cp resources.pack "$(RELEASE_FOLDER)"
cp LICENSE "$(RELEASE_FOLDER)"
cp README.md "$(RELEASE_FOLDER)"
@@ -291,7 +297,8 @@ linux_release_desktop:
$(MKDIR) "$(RELEASE_FOLDER)/$(TARGET_NAME)/share/$(TARGET_NAME)"
# Copia ficheros del juego
cp -R data "$(RELEASE_FOLDER)/$(TARGET_NAME)/share/$(TARGET_NAME)/"
cp -R config "$(RELEASE_FOLDER)/$(TARGET_NAME)/share/$(TARGET_NAME)/"
cp resources.pack "$(RELEASE_FOLDER)/$(TARGET_NAME)/share/$(TARGET_NAME)/"
cp LICENSE "$(RELEASE_FOLDER)/$(TARGET_NAME)/"
cp README.md "$(RELEASE_FOLDER)/$(TARGET_NAME)/"
@@ -391,7 +398,8 @@ raspi_release:
$(MKDIR) "$(RELEASE_FOLDER)"
# Copia ficheros
cp -R data "$(RELEASE_FOLDER)"
cp -R config "$(RELEASE_FOLDER)"
cp resources.pack "$(RELEASE_FOLDER)"
cp LICENSE "$(RELEASE_FOLDER)"
cp README.md "$(RELEASE_FOLDER)"
@@ -416,7 +424,8 @@ anbernic:
$(MKDIR) "$(RELEASE_FOLDER)"_anbernic
# Copia ficheros
cp -R data "$(RELEASE_FOLDER)"_anbernic
cp -R config "$(RELEASE_FOLDER)"_anbernic
cp resources.pack "$(RELEASE_FOLDER)"_anbernic
# Compila
$(CXX) $(APP_SOURCES) $(INCLUDES) -DANBERNIC -DNO_SHADERS -DARCADE -DVERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(RELEASE_FOLDER)_anbernic/$(TARGET_NAME)

21
data/config/assets.txt → config/assets.txt
View File

@@ -9,15 +9,17 @@ DATA|${SYSTEM_FOLDER}/controllers.json|optional,absolute
DATA|${SYSTEM_FOLDER}/score.bin|optional,absolute
# Archivos de configuración del juego
DATA|${PREFIX}/data/config/formations.txt
DATA|${PREFIX}/data/config/gamecontrollerdb.txt
DATA|${PREFIX}/data/config/param_320x240.txt
DATA|${PREFIX}/data/config/param_320x256.txt
DATA|${PREFIX}/data/config/param_red.txt
DATA|${PREFIX}/data/config/pools.txt
DATA|${PREFIX}/data/config/stages.txt
DEMODATA|${PREFIX}/data/config/demo1.bin
DEMODATA|${PREFIX}/data/config/demo2.bin
DATA|${PREFIX}/config/formations.txt
DATA|${PREFIX}/config/gamecontrollerdb.txt
DATA|${PREFIX}/config/param_320x240.txt
DATA|${PREFIX}/config/param_320x256.txt
DATA|${PREFIX}/config/param_red.txt
DATA|${PREFIX}/config/pools.txt
DATA|${PREFIX}/config/stages.txt
# Archivos con los datos de la demo
DEMODATA|${PREFIX}/data/demo/demo1.bin
DEMODATA|${PREFIX}/data/demo/demo2.bin
# Música
MUSIC|${PREFIX}/data/music/credits.ogg
@@ -50,6 +52,7 @@ SOUND|${PREFIX}/data/sound/notify.wav
SOUND|${PREFIX}/data/sound/player_collision.wav
SOUND|${PREFIX}/data/sound/power_ball_explosion.wav
SOUND|${PREFIX}/data/sound/service_menu_adjust.wav
SOUND|${PREFIX}/data/sound/service_menu_back.wav
SOUND|${PREFIX}/data/sound/service_menu_move.wav
SOUND|${PREFIX}/data/sound/service_menu_select.wav
SOUND|${PREFIX}/data/sound/stage_change.wav

0
data/config/formations.txt → config/formations.txt
View File

0
data/config/gamecontrollerdb.txt → config/gamecontrollerdb.txt
View File

0
data/config/param_320x240.txt → config/param_320x240.txt
View File

0
data/config/param_320x256.txt → config/param_320x256.txt
View File

0
data/config/param_red.txt → config/param_red.txt
View File

0
data/config/pools.txt → config/pools.txt
View File

0
data/config/stages.txt → config/stages.txt
View File

0
data/config/demo1.bin → data/demo/demo1.bin
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 12 KiB

After

Width:  |  Height:  |  Size: 12 KiB

0
data/config/demo2.bin → data/demo/demo2.bin
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 12 KiB

After

Width:  |  Height:  |  Size: 12 KiB

BIN
data/sound/click-2.wav Normal file
View File

Binary file not shown.

BIN
data/sound/click-3.wav Normal file
View File

Binary file not shown.

BIN
data/sound/service_menu_back.wav Normal file
View File

Binary file not shown.

BIN
data/sound/service_menu_move.wav
View File

Binary file not shown.

BIN
release/libgcc_s_seh-1.dll
View File

Binary file not shown.

BIN
release/libstdc++-6.dll
View File

Binary file not shown.

BIN
release/libwinpthread-1.dll
View File

Binary file not shown.

28
source/animated_sprite.cpp
View File

@@ -10,21 +10,39 @@
#include <utility> // Para pair
#include "texture.h" // Para Texture
#include "resource_helper.h" // Para ResourceHelper
#include "utils.h" // Para printWithDots
// Carga las animaciones en un vector(Animations) desde un fichero
auto loadAnimationsFromFile(const std::string& file_path) -> AnimationsFileBuffer {
std::ifstream file(file_path);
if (!file) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
throw std::runtime_error("Fichero no encontrado: " + file_path);
// Intentar cargar desde ResourceHelper primero
auto resource_data = ResourceHelper::loadFile(file_path);
std::istringstream stream;
bool using_resource_data = false;
if (!resource_data.empty()) {
std::string content(resource_data.begin(), resource_data.end());
stream.str(content);
using_resource_data = true;
}
// Fallback a archivo directo
std::ifstream file;
if (!using_resource_data) {
file.open(file_path);
if (!file) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
throw std::runtime_error("Fichero no encontrado: " + file_path);
}
}
std::istream& input_stream = using_resource_data ? stream : static_cast<std::istream&>(file);
printWithDots("Animation : ", file_path.substr(file_path.find_last_of("\\/") + 1), "[ LOADED ]");
std::vector<std::string> buffer;
std::string line;
while (std::getline(file, line)) {
while (std::getline(input_stream, line)) {
if (!line.empty()) {
buffer.push_back(line);
}

25
source/asset.cpp
View File

@@ -9,6 +9,7 @@
#include <stdexcept> // Para runtime_error
#include "utils.h" // Para getFileName
#include "resource_helper.h" // Para ResourceHelper
// Singleton
Asset *Asset::instance = nullptr;
@@ -139,6 +140,17 @@ auto Asset::get(const std::string &filename) const -> std::string {
return "";
}
// Carga datos del archivo usando ResourceHelper
auto Asset::loadData(const std::string &filename) const -> std::vector<uint8_t> {
auto it = file_list_.find(filename);
if (it != file_list_.end()) {
return ResourceHelper::loadFile(it->second.file);
}
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Warning: file %s not found for data loading", filename.c_str());
return {};
}
// Verifica si un recurso existe
auto Asset::exists(const std::string &filename) const -> bool {
return file_list_.find(filename) != file_list_.end();
@@ -194,9 +206,16 @@ auto Asset::check() const -> bool {
// Comprueba que existe un fichero
auto Asset::checkFile(const std::string &path) -> bool {
std::ifstream file(path);
bool success = file.good();
file.close();
// Intentar primero con ResourceHelper
auto data = ResourceHelper::loadFile(path);
bool success = !data.empty();
// Si no se encuentra en el pack, intentar con filesystem directo
if (!success) {
std::ifstream file(path);
success = file.good();
file.close();
}
if (!success) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

2
source/asset.h
View File

@@ -4,6 +4,7 @@
#include <unordered_map> // Para unordered_map
#include <utility> // Para move
#include <vector> // Para vector
#include <cstdint> // Para uint8_t
// --- Clase Asset: gestor optimizado de recursos (singleton) ---
class Asset {
@@ -33,6 +34,7 @@ class Asset {
void add(const std::string &file_path, Type type, bool required = true, bool absolute = false);
void loadFromFile(const std::string &config_file_path, const std::string &prefix = "", const std::string &system_folder = ""); // Con soporte para variables
[[nodiscard]] auto get(const std::string &filename) const -> std::string; // Mantener nombre original
[[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; // Nueva función para verificar existencia

105
source/asset_integrated.cpp Normal file
View File

@@ -0,0 +1,105 @@
#include "asset_integrated.h"
#include <filesystem>
#include <iostream>
#include <fstream>
bool AssetIntegrated::resource_pack_enabled_ = false;
void AssetIntegrated::initWithResourcePack(const std::string &executable_path,
const std::string &resource_pack_path) {
// Inicializar Asset normal
Asset::init(executable_path);
// Inicializar ResourceLoader
auto& loader = ResourceLoader::getInstance();
if (loader.initialize(resource_pack_path, true)) {
resource_pack_enabled_ = true;
std::cout << "Asset system initialized with resource pack: " << resource_pack_path << std::endl;
} else {
resource_pack_enabled_ = false;
std::cout << "Asset system initialized in fallback mode (filesystem)" << std::endl;
}
}
std::vector<uint8_t> AssetIntegrated::loadFile(const std::string &filename) {
if (shouldUseResourcePack(filename) && resource_pack_enabled_) {
// Intentar cargar del pack de recursos
auto& loader = ResourceLoader::getInstance();
// Convertir ruta completa a ruta relativa para el pack
std::string relativePath = filename;
// Si la ruta contiene "data/", extraer la parte relativa
size_t dataPos = filename.find("data/");
if (dataPos != std::string::npos) {
relativePath = filename.substr(dataPos + 5); // +5 para saltar "data/"
}
auto data = loader.loadResource(relativePath);
if (!data.empty()) {
return data;
}
}
// Fallback: cargar del filesystem
std::ifstream file(filename, std::ios::binary | std::ios::ate);
if (!file) {
std::cerr << "Error: Could not open file: " << filename << std::endl;
return {};
}
std::streamsize fileSize = file.tellg();
file.seekg(0, std::ios::beg);
std::vector<uint8_t> data(fileSize);
if (!file.read(reinterpret_cast<char*>(data.data()), fileSize)) {
std::cerr << "Error: Could not read file: " << filename << std::endl;
return {};
}
return data;
}
bool AssetIntegrated::fileExists(const std::string &filename) const {
if (shouldUseResourcePack(filename) && resource_pack_enabled_) {
auto& loader = ResourceLoader::getInstance();
// Convertir ruta completa a ruta relativa para el pack
std::string relativePath = filename;
size_t dataPos = filename.find("data/");
if (dataPos != std::string::npos) {
relativePath = filename.substr(dataPos + 5);
}
if (loader.resourceExists(relativePath)) {
return true;
}
}
// Verificar en filesystem
return std::filesystem::exists(filename);
}
std::string AssetIntegrated::getSystemPath(const std::string &filename) const {
// Los archivos de sistema/config siempre van al filesystem
return filename;
}
bool AssetIntegrated::shouldUseResourcePack(const std::string &filepath) const {
// Los archivos que NO van al pack:
// - Archivos de config/ (ahora están fuera de data/)
// - Archivos con absolute=true en assets.txt
// - Archivos de sistema (${SYSTEM_FOLDER})
if (filepath.find("/config/") != std::string::npos ||
filepath.find("config/") == 0) {
return false;
}
if (filepath.find("/data/") != std::string::npos ||
filepath.find("data/") == 0) {
return true;
}
return false;
}

28
source/asset_integrated.h Normal file
View File

@@ -0,0 +1,28 @@
#pragma once
#include "asset.h"
#include "resource_loader.h"
#include <memory>
// Extensión de Asset que integra ResourceLoader
class AssetIntegrated : public Asset {
public:
// Inicializa Asset con ResourceLoader
static void initWithResourcePack(const std::string &executable_path,
const std::string &resource_pack_path = "resources.pack");
// Carga un archivo usando ResourceLoader como primera opción
std::vector<uint8_t> loadFile(const std::string &filename);
// Verifica si un archivo existe (pack o filesystem)
bool fileExists(const std::string &filename) const;
// Obtiene la ruta completa para archivos del sistema/config
std::string getSystemPath(const std::string &filename) const;
private:
static bool resource_pack_enabled_;
// Determina si un archivo debe cargarse del pack o del filesystem
bool shouldUseResourcePack(const std::string &filepath) const;
};

9
source/director.cpp
View File

@@ -18,6 +18,7 @@
#include "manage_hiscore_table.h" // Para ManageHiScoreTable
#include "options.h" // Para loadFromFile, saveToFile, Settings, settings, setConfigFile, setControllersFile
#include "param.h" // Para loadParamsFromFile
#include "resource_helper.h" // Para ResourceHelper
#include "player.h" // Para Player
#include "resource.h" // Para Resource
#include "screen.h" // Para Screen
@@ -77,6 +78,12 @@ Director::~Director() {
void Director::init() {
// Configuración inicial de parametros
Asset::init(executable_path_); // Inicializa el sistema de gestión de archivos
#ifdef MACOS_BUNDLE
ResourceHelper::initializeResourceSystem(executable_path_ + "/../Resources/resources.pack");
#else
ResourceHelper::initializeResourceSystem("resources.pack");
#endif
loadAssets(); // Crea el índice de archivos
Input::init(Asset::get()->get("gamecontrollerdb.txt"), Asset::get()->get("controllers.json")); // Carga configuración de controles
Options::setConfigFile(Asset::get()->get("config.txt")); // Establece el fichero de configuración
@@ -154,7 +161,7 @@ void Director::loadAssets() {
#endif
// Cargar la configuración de assets (también aplicar el prefijo al archivo de configuración)
std::string config_path = executable_path_ + PREFIX + "/data/config/assets.txt";
std::string config_path = executable_path_ + PREFIX + "/config/assets.txt";
Asset::get()->loadFromFile(config_path, PREFIX, system_folder_);
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Assets configuration loaded successfully");

23
source/lang.cpp
View File

@@ -11,6 +11,7 @@
#include "difficulty.h" // Para Difficulty
#include "external/json.hpp" // Para basic_json, iteration_proxy_value, oper...
#include "options.h" // Para SettingsOpt...
#include "resource_helper.h" // Para ResourceHelper
using json = nlohmann::json;
@@ -27,14 +28,24 @@ std::vector<Language> languages = {
auto loadFromFile(const std::string &file_path) -> bool {
texts.clear();
std::ifstream rfile(file_path);
if (!rfile.is_open()) {
return false;
}
// Intentar cargar desde ResourceHelper primero
auto resource_data = ResourceHelper::loadFile(file_path);
try {
json j;
rfile >> j;
if (!resource_data.empty()) {
// Cargar desde datos del pack
std::string content(resource_data.begin(), resource_data.end());
j = json::parse(content);
} else {
// Fallback a filesystem directo
std::ifstream rfile(file_path);
if (!rfile.is_open()) {
return false;
}
rfile >> j;
}
for (const auto &el : j.items()) {
texts[el.key()] = el.value();

65
source/resource.cpp
View File

@@ -4,7 +4,9 @@
#include <algorithm> // Para find_if, max, find
#include <array> // Para array
#include <cstdlib> // Para exit
#include <cstdlib> // Para exit, getenv
#include <filesystem> // Para filesystem::remove, filesystem::exists
#include <fstream> // Para ofstream
#include <stdexcept> // Para runtime_error
#include <utility> // Para move
@@ -17,10 +19,41 @@
#include "param.h" // Para Param, param, ParamResource, ParamGame
#include "screen.h" // Para Screen
#include "text.h" // Para Text
#include "resource_helper.h" // Para ResourceHelper
struct JA_Music_t; // lines 11-11
struct JA_Sound_t; // lines 12-12
// Helper para cargar archivos de audio desde pack o filesystem
namespace {
std::string createTempAudioFile(const std::string& file_path, std::vector<std::string>& temp_files_tracker) {
auto resource_data = ResourceHelper::loadFile(file_path);
if (!resource_data.empty()) {
// Crear archivo temporal
std::string temp_dir;
#ifdef _WIN32
temp_dir = std::getenv("TEMP") ? std::getenv("TEMP") : "C:\\temp";
#else
temp_dir = "/tmp";
#endif
std::string temp_path = temp_dir + "/ccae_audio_" + std::to_string(std::hash<std::string>{}(file_path));
std::ofstream temp_file(temp_path, std::ios::binary);
if (!temp_file) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Cannot create temp file %s", temp_path.c_str());
return file_path;
}
temp_file.write(reinterpret_cast<const char*>(resource_data.data()), resource_data.size());
temp_file.close();
// Agregar a la lista de archivos temporales para limpieza posterior
temp_files_tracker.push_back(temp_path);
return temp_path;
}
return file_path; // Usar ruta original si no está en pack
}
}
// Declaraciones de funciones que necesitas implementar en otros archivos
// Singleton
@@ -55,6 +88,7 @@ Resource::Resource(LoadingMode mode)
// Destructor
Resource::~Resource() {
cleanupTempAudioFiles();
clear();
}
@@ -293,7 +327,8 @@ auto Resource::loadSoundLazy(const std::string &name) -> JA_Sound_t * {
auto sound_list = Asset::get()->getListByType(Asset::Type::SOUND);
for (const auto &file : sound_list) {
if (getFileName(file) == name) {
return JA_LoadSound(file.c_str());
std::string audio_path = createTempAudioFile(file, Resource::get()->temp_audio_files_);
return JA_LoadSound(audio_path.c_str());
}
}
#endif
@@ -306,7 +341,8 @@ auto Resource::loadMusicLazy(const std::string &name) -> JA_Music_t * {
auto music_list = Asset::get()->getListByType(Asset::Type::MUSIC);
for (const auto &file : music_list) {
if (getFileName(file) == name) {
return JA_LoadMusic(file.c_str());
std::string audio_path = createTempAudioFile(file, Resource::get()->temp_audio_files_);
return JA_LoadMusic(audio_path.c_str());
}
}
#endif
@@ -448,7 +484,8 @@ void Resource::loadSounds() {
auto name = getFileName(l);
updateLoadingProgress(name);
#ifndef NO_AUDIO
sounds_.emplace_back(name, JA_LoadSound(l.c_str()));
std::string audio_path = createTempAudioFile(l, temp_audio_files_);
sounds_.emplace_back(name, JA_LoadSound(audio_path.c_str()));
#else
sounds_.emplace_back(name, nullptr);
#endif
@@ -466,7 +503,8 @@ void Resource::loadMusics() {
auto name = getFileName(l);
updateLoadingProgress(name);
#ifndef NO_AUDIO
musics_.emplace_back(name, JA_LoadMusic(l.c_str()));
std::string audio_path = createTempAudioFile(l, temp_audio_files_);
musics_.emplace_back(name, JA_LoadMusic(audio_path.c_str()));
#else
musics_.emplace_back(name, nullptr);
#endif
@@ -567,7 +605,7 @@ void Resource::createPlayerTextures() {
texture->setPaletteColor(0, 19, param.player.default_shirt[player_idx].light.TO_UINT32());
texture->setPaletteColor(0, 56, param.player.outline_color[player_idx].TO_UINT32());
} else {
// Crear textura nueva desde archivo
// Crear textura nueva desde archivo usando ResourceHelper
texture = std::make_shared<Texture>(Screen::get()->getRenderer(), texture_file_path);
// Añadir todas las paletas
@@ -833,3 +871,18 @@ void Resource::updateLoadingProgress(std::string name) {
void Resource::updateProgressBar() {
loading_full_rect_.w = loading_wired_rect_.w * loading_count_.getPercentage();
}
// Limpia archivos temporales de audio
void Resource::cleanupTempAudioFiles() {
for (const auto& temp_path : temp_audio_files_) {
try {
if (std::filesystem::exists(temp_path)) {
std::filesystem::remove(temp_path);
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Removed temp audio file: %s", temp_path.c_str());
}
} catch (const std::exception& e) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to remove temp audio file %s: %s", temp_path.c_str(), e.what());
}
}
temp_audio_files_.clear();
}

4
source/resource.h
View File

@@ -128,6 +128,9 @@ class Resource {
std::string loading_resource_name_; // Nombre del recurso que se está cargando
SDL_FRect loading_wired_rect_;
SDL_FRect loading_full_rect_;
// --- Archivos temporales ---
std::vector<std::string> temp_audio_files_; // Rutas de archivos temporales de audio para limpieza
// --- Métodos internos de carga y gestión ---
void loadSounds(); // Carga los sonidos
@@ -147,6 +150,7 @@ class Resource {
void load(); // Carga todos los recursos
void clearSounds(); // Vacía el vector de sonidos
void clearMusics(); // Vacía el vector de músicas
void cleanupTempAudioFiles(); // Limpia archivos temporales de audio
// --- Métodos para carga perezosa ---
void initResourceLists(); // Inicializa las listas de recursos sin cargar el contenido

95
source/resource_helper.cpp Normal file
View File

@@ -0,0 +1,95 @@
#include "resource_helper.h"
#include <filesystem>
#include <fstream>
#include <iostream>
#include <algorithm>
namespace ResourceHelper {
static bool resource_system_initialized = false;
bool initializeResourceSystem(const std::string& pack_file) {
auto& loader = ResourceLoader::getInstance();
resource_system_initialized = loader.initialize(pack_file, true);
if (resource_system_initialized) {
std::cout << "Resource system initialized with pack: " << pack_file << std::endl;
} else {
std::cout << "Resource system using fallback mode (filesystem only)" << std::endl;
}
return true; // Always return true as fallback is acceptable
}
void shutdownResourceSystem() {
if (resource_system_initialized) {
ResourceLoader::getInstance().shutdown();
resource_system_initialized = false;
}
}
std::vector<uint8_t> loadFile(const std::string& filepath) {
if (resource_system_initialized && shouldUseResourcePack(filepath)) {
auto& loader = ResourceLoader::getInstance();
std::string pack_path = getPackPath(filepath);
auto data = loader.loadResource(pack_path);
if (!data.empty()) {
return data;
}
}
// Fallback a filesystem
std::ifstream file(filepath, std::ios::binary | std::ios::ate);
if (!file) {
return {};
}
std::streamsize fileSize = file.tellg();
file.seekg(0, std::ios::beg);
std::vector<uint8_t> data(fileSize);
if (!file.read(reinterpret_cast<char*>(data.data()), fileSize)) {
return {};
}
return data;
}
bool shouldUseResourcePack(const std::string& filepath) {
// Archivos que NO van al pack:
// - config/ (ahora está fuera de data/)
// - archivos absolutos del sistema
if (filepath.find("config/") != std::string::npos) {
return false;
}
// Si contiene "data/" es candidato para el pack
if (filepath.find("data/") != std::string::npos) {
return true;
}
return false;
}
std::string getPackPath(const std::string& asset_path) {
std::string pack_path = asset_path;
// Normalizar separadores de path a '/'
std::replace(pack_path.begin(), pack_path.end(), '\\', '/');
// Remover prefijo "data/" si existe
size_t data_pos = pack_path.find("data/");
if (data_pos != std::string::npos) {
pack_path = pack_path.substr(data_pos + 5); // +5 para saltar "data/"
}
// Remover cualquier prefijo de path absoluto
size_t last_data = pack_path.rfind("data/");
if (last_data != std::string::npos) {
pack_path = pack_path.substr(last_data + 5);
}
return pack_path;
}
}

46
source/resource_helper.h Normal file
View File

@@ -0,0 +1,46 @@
#pragma once
#include "resource_loader.h"
#include <string>
#include <vector>
#include <memory>
#include <filesystem>
#include <fstream>
// Helper functions para integrar ResourceLoader con el sistema existente
namespace ResourceHelper {
// Inicializa ResourceLoader (llamar al inicio del programa)
bool initializeResourceSystem(const std::string& pack_file = "resources.pack");
// Cierra ResourceLoader
void shutdownResourceSystem();
// Carga un archivo usando ResourceLoader o fallback a filesystem
std::vector<uint8_t> loadFile(const std::string& filepath);
// Verifica si un archivo debería cargarse del pack vs filesystem
bool shouldUseResourcePack(const std::string& filepath);
// Convierte ruta Asset a ruta relativa para ResourceLoader
std::string getPackPath(const std::string& asset_path);
// Wrappea la carga de archivos para mantener compatibilidad
template<typename T>
T* loadResourceFile(const std::string& asset_path, T* (*loader_func)(const char*)) {
auto data = loadFile(asset_path);
if (data.empty()) {
return loader_func(asset_path.c_str());
}
// Crear archivo temporal para funciones que esperan path
std::string temp_path = "/tmp/ccae_" + std::to_string(std::hash<std::string>{}(asset_path));
std::ofstream temp_file(temp_path, std::ios::binary);
temp_file.write(reinterpret_cast<const char*>(data.data()), data.size());
temp_file.close();
T* result = loader_func(temp_path.c_str());
std::filesystem::remove(temp_path);
return result;
}
}

133
source/resource_loader.cpp Normal file
View File

@@ -0,0 +1,133 @@
#include "resource_loader.h"
#include <fstream>
#include <iostream>
#include <filesystem>
#include <algorithm>
std::unique_ptr<ResourceLoader> ResourceLoader::instance = nullptr;
ResourceLoader::ResourceLoader()
: resourcePack(nullptr), fallbackToFiles(true) {}
ResourceLoader& ResourceLoader::getInstance() {
if (!instance) {
instance = std::unique_ptr<ResourceLoader>(new ResourceLoader());
}
return *instance;
}
ResourceLoader::~ResourceLoader() {
shutdown();
}
bool ResourceLoader::initialize(const std::string& packFile, bool enableFallback) {
shutdown();
fallbackToFiles = enableFallback;
packPath = packFile;
if (std::filesystem::exists(packFile)) {
resourcePack = new ResourcePack();
if (resourcePack->loadPack(packFile)) {
std::cout << "Resource pack loaded successfully: " << packFile << std::endl;
std::cout << "Resources available: " << resourcePack->getResourceCount() << std::endl;
return true;
} else {
delete resourcePack;
resourcePack = nullptr;
std::cerr << "Failed to load resource pack: " << packFile << std::endl;
}
}
if (fallbackToFiles) {
std::cout << "Using fallback mode: loading resources from data/ directory" << std::endl;
return true;
}
std::cerr << "Resource pack not found and fallback disabled: " << packFile << std::endl;
return false;
}
void ResourceLoader::shutdown() {
if (resourcePack) {
delete resourcePack;
resourcePack = nullptr;
}
}
std::vector<uint8_t> ResourceLoader::loadResource(const std::string& filename) {
if (resourcePack && resourcePack->hasResource(filename)) {
return resourcePack->getResource(filename);
}
if (fallbackToFiles) {
return loadFromFile(filename);
}
std::cerr << "Resource not found: " << filename << std::endl;
return {};
}
bool ResourceLoader::resourceExists(const std::string& filename) {
if (resourcePack && resourcePack->hasResource(filename)) {
return true;
}
if (fallbackToFiles) {
std::string fullPath = getDataPath(filename);
return std::filesystem::exists(fullPath);
}
return false;
}
std::vector<uint8_t> ResourceLoader::loadFromFile(const std::string& filename) {
std::string fullPath = getDataPath(filename);
std::ifstream file(fullPath, std::ios::binary | std::ios::ate);
if (!file) {
std::cerr << "Error: Could not open file: " << fullPath << std::endl;
return {};
}
std::streamsize fileSize = file.tellg();
file.seekg(0, std::ios::beg);
std::vector<uint8_t> data(fileSize);
if (!file.read(reinterpret_cast<char*>(data.data()), fileSize)) {
std::cerr << "Error: Could not read file: " << fullPath << std::endl;
return {};
}
return data;
}
std::string ResourceLoader::getDataPath(const std::string& filename) {
return "data/" + filename;
}
size_t ResourceLoader::getLoadedResourceCount() const {
if (resourcePack) {
return resourcePack->getResourceCount();
}
return 0;
}
std::vector<std::string> ResourceLoader::getAvailableResources() const {
if (resourcePack) {
return resourcePack->getResourceList();
}
std::vector<std::string> result;
if (fallbackToFiles && std::filesystem::exists("data")) {
for (const auto& entry : std::filesystem::recursive_directory_iterator("data")) {
if (entry.is_regular_file()) {
std::string filename = std::filesystem::relative(entry.path(), "data").string();
std::replace(filename.begin(), filename.end(), '\\', '/');
result.push_back(filename);
}
}
}
return result;
}

37
source/resource_loader.h Normal file
View File

@@ -0,0 +1,37 @@
#ifndef RESOURCE_LOADER_H
#define RESOURCE_LOADER_H
#include "resource_pack.h"
#include <memory>
class ResourceLoader {
private:
static std::unique_ptr<ResourceLoader> instance;
ResourcePack* resourcePack;
std::string packPath;
bool fallbackToFiles;
ResourceLoader();
public:
static ResourceLoader& getInstance();
~ResourceLoader();
bool initialize(const std::string& packFile, bool enableFallback = true);
void shutdown();
std::vector<uint8_t> loadResource(const std::string& filename);
bool resourceExists(const std::string& filename);
void setFallbackToFiles(bool enable) { fallbackToFiles = enable; }
bool getFallbackToFiles() const { return fallbackToFiles; }
size_t getLoadedResourceCount() const;
std::vector<std::string> getAvailableResources() const;
private:
std::vector<uint8_t> loadFromFile(const std::string& filename);
std::string getDataPath(const std::string& filename);
};
#endif

222
source/resource_pack.cpp Normal file
View File

@@ -0,0 +1,222 @@
#include "resource_pack.h"
#include <fstream>
#include <iostream>
#include <filesystem>
#include <algorithm>
const std::string ResourcePack::DEFAULT_ENCRYPT_KEY = "CCAE_RESOURCES_2024";
ResourcePack::ResourcePack() : loaded(false) {}
ResourcePack::~ResourcePack() {
clear();
}
uint32_t ResourcePack::calculateChecksum(const std::vector<uint8_t>& data) {
uint32_t checksum = 0x12345678;
for (size_t i = 0; i < data.size(); ++i) {
checksum = ((checksum << 5) + checksum) + data[i];
}
return checksum;
}
void ResourcePack::encryptData(std::vector<uint8_t>& data, const std::string& key) {
if (key.empty()) return;
for (size_t i = 0; i < data.size(); ++i) {
data[i] ^= key[i % key.length()];
}
}
void ResourcePack::decryptData(std::vector<uint8_t>& data, const std::string& key) {
encryptData(data, key);
}
bool ResourcePack::loadPack(const std::string& packFile) {
std::ifstream file(packFile, std::ios::binary);
if (!file) {
std::cerr << "Error: Could not open pack file: " << packFile << std::endl;
return false;
}
char header[4];
file.read(header, 4);
if (std::string(header, 4) != "CCAE") {
std::cerr << "Error: Invalid pack file format" << std::endl;
return false;
}
uint32_t version;
file.read(reinterpret_cast<char*>(&version), sizeof(version));
if (version != 1) {
std::cerr << "Error: Unsupported pack version: " << version << std::endl;
return false;
}
uint32_t resourceCount;
file.read(reinterpret_cast<char*>(&resourceCount), sizeof(resourceCount));
resources.clear();
resources.reserve(resourceCount);
for (uint32_t i = 0; i < resourceCount; ++i) {
uint32_t filenameLength;
file.read(reinterpret_cast<char*>(&filenameLength), sizeof(filenameLength));
std::string filename(filenameLength, '\0');
file.read(&filename[0], filenameLength);
ResourceEntry entry;
entry.filename = filename;
file.read(reinterpret_cast<char*>(&entry.offset), sizeof(entry.offset));
file.read(reinterpret_cast<char*>(&entry.size), sizeof(entry.size));
file.read(reinterpret_cast<char*>(&entry.checksum), sizeof(entry.checksum));
resources[filename] = entry;
}
uint64_t dataSize;
file.read(reinterpret_cast<char*>(&dataSize), sizeof(dataSize));
data.resize(dataSize);
file.read(reinterpret_cast<char*>(data.data()), dataSize);
decryptData(data, DEFAULT_ENCRYPT_KEY);
loaded = true;
return true;
}
bool ResourcePack::savePack(const std::string& packFile) {
std::ofstream file(packFile, std::ios::binary);
if (!file) {
std::cerr << "Error: Could not create pack file: " << packFile << std::endl;
return false;
}
file.write("CCAE", 4);
uint32_t version = 1;
file.write(reinterpret_cast<const char*>(&version), sizeof(version));
uint32_t resourceCount = static_cast<uint32_t>(resources.size());
file.write(reinterpret_cast<const char*>(&resourceCount), sizeof(resourceCount));
for (const auto& [filename, entry] : resources) {
uint32_t filenameLength = static_cast<uint32_t>(filename.length());
file.write(reinterpret_cast<const char*>(&filenameLength), sizeof(filenameLength));
file.write(filename.c_str(), filenameLength);
file.write(reinterpret_cast<const char*>(&entry.offset), sizeof(entry.offset));
file.write(reinterpret_cast<const char*>(&entry.size), sizeof(entry.size));
file.write(reinterpret_cast<const char*>(&entry.checksum), sizeof(entry.checksum));
}
std::vector<uint8_t> encryptedData = data;
encryptData(encryptedData, DEFAULT_ENCRYPT_KEY);
uint64_t dataSize = encryptedData.size();
file.write(reinterpret_cast<const char*>(&dataSize), sizeof(dataSize));
file.write(reinterpret_cast<const char*>(encryptedData.data()), dataSize);
return true;
}
bool ResourcePack::addFile(const std::string& filename, const std::string& filepath) {
std::ifstream file(filepath, std::ios::binary | std::ios::ate);
if (!file) {
std::cerr << "Error: Could not open file: " << filepath << std::endl;
return false;
}
std::streamsize fileSize = file.tellg();
file.seekg(0, std::ios::beg);
std::vector<uint8_t> fileData(fileSize);
if (!file.read(reinterpret_cast<char*>(fileData.data()), fileSize)) {
std::cerr << "Error: Could not read file: " << filepath << std::endl;
return false;
}
ResourceEntry entry;
entry.filename = filename;
entry.offset = data.size();
entry.size = fileData.size();
entry.checksum = calculateChecksum(fileData);
data.insert(data.end(), fileData.begin(), fileData.end());
resources[filename] = entry;
return true;
}
bool ResourcePack::addDirectory(const std::string& directory) {
if (!std::filesystem::exists(directory)) {
std::cerr << "Error: Directory does not exist: " << directory << std::endl;
return false;
}
for (const auto& entry : std::filesystem::recursive_directory_iterator(directory)) {
if (entry.is_regular_file()) {
std::string filepath = entry.path().string();
std::string filename = std::filesystem::relative(entry.path(), directory).string();
std::replace(filename.begin(), filename.end(), '\\', '/');
if (!addFile(filename, filepath)) {
return false;
}
}
}
return true;
}
std::vector<uint8_t> ResourcePack::getResource(const std::string& filename) {
auto it = resources.find(filename);
if (it == resources.end()) {
std::cerr << "Error: Resource not found: " << filename << std::endl;
return {};
}
const ResourceEntry& entry = it->second;
if (entry.offset + entry.size > data.size()) {
std::cerr << "Error: Invalid resource data: " << filename << std::endl;
return {};
}
std::vector<uint8_t> result(data.begin() + entry.offset,
data.begin() + entry.offset + entry.size);
uint32_t checksum = calculateChecksum(result);
if (checksum != entry.checksum) {
std::cerr << "Warning: Checksum mismatch for resource: " << filename << std::endl;
}
return result;
}
bool ResourcePack::hasResource(const std::string& filename) const {
return resources.find(filename) != resources.end();
}
void ResourcePack::clear() {
resources.clear();
data.clear();
loaded = false;
}
size_t ResourcePack::getResourceCount() const {
return resources.size();
}
std::vector<std::string> ResourcePack::getResourceList() const {
std::vector<std::string> result;
result.reserve(resources.size());
for (const auto& [filename, entry] : resources) {
result.push_back(filename);
}
return result;
}

46
source/resource_pack.h Normal file
View File

@@ -0,0 +1,46 @@
#ifndef RESOURCE_PACK_H
#define RESOURCE_PACK_H
#include <string>
#include <unordered_map>
#include <vector>
#include <cstdint>
struct ResourceEntry {
std::string filename;
uint64_t offset;
uint64_t size;
uint32_t checksum;
};
class ResourcePack {
private:
std::unordered_map<std::string, ResourceEntry> resources;
std::vector<uint8_t> data;
bool loaded;
uint32_t calculateChecksum(const std::vector<uint8_t>& data);
void encryptData(std::vector<uint8_t>& data, const std::string& key);
void decryptData(std::vector<uint8_t>& data, const std::string& key);
public:
ResourcePack();
~ResourcePack();
bool loadPack(const std::string& packFile);
bool savePack(const std::string& packFile);
bool addFile(const std::string& filename, const std::string& filepath);
bool addDirectory(const std::string& directory);
std::vector<uint8_t> getResource(const std::string& filename);
bool hasResource(const std::string& filename) const;
void clear();
size_t getResourceCount() const;
std::vector<std::string> getResourceList() const;
static const std::string DEFAULT_ENCRYPT_KEY;
};
#endif

20
source/scoreboard.cpp
View File

@@ -37,10 +37,7 @@ auto Scoreboard::get() -> Scoreboard * {
// Constructor
Scoreboard::Scoreboard()
: renderer_(Screen::get()->getRenderer()),
game_power_meter_texture_(Resource::get()->getTexture("game_power_meter.png")),
power_meter_sprite_(std::make_unique<Sprite>(game_power_meter_texture_)),
text_scoreboard_(Resource::get()->getText("8bithud")) {
: renderer_(Screen::get()->getRenderer()), game_power_meter_texture_(Resource::get()->getTexture("game_power_meter.png")), power_meter_sprite_(std::make_unique<Sprite>(game_power_meter_texture_)), text_scoreboard_(Resource::get()->getText("8bithud")) {
// Inicializa variables
for (size_t i = 0; i < static_cast<size_t>(Id::SIZE); ++i) {
name_.at(i).clear();
@@ -284,17 +281,18 @@ void Scoreboard::renderNameInputField(size_t panel_index) {
// Selecciona el color
const Color COLOR = j < selector_pos_.at(panel_index) ? text_color2_ : text_color1_;
if (j != selector_pos_.at(panel_index) || time_counter_ % 3 == 0) {
// Dibuja la linea
// Dibuja la linea. Si coincide con el selector solo se dibuja 2 de cada 4 veces
if (j != selector_pos_.at(panel_index) || time_counter_ % 4 >= 2) {
// Si está a la derecha del selector, se dibuja siempre
if (j >= selector_pos_.at(panel_index)) {
SDL_SetRenderDrawColor(renderer_, COLOR.r, COLOR.g, COLOR.b, 255);
SDL_RenderLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
}
// Dibuja la letra
if (j < record_name_.at(panel_index).size()) {
text_scoreboard_->writeColored(rect.x, rect.y, record_name_.at(panel_index).substr(j, 1), COLOR);
}
}
// Dibuja la letra
if (j < record_name_.at(panel_index).size()) {
text_scoreboard_->writeColored(rect.x, rect.y, record_name_.at(panel_index).substr(j, 1), COLOR);
}
rect.x += 7;
}

6
source/screen.cpp
View File

@@ -224,8 +224,10 @@ void Screen::renderInfo() {
void Screen::loadShaders() {
if (shader_source_.empty()) {
const std::string GLSL_FILE = param.game.game_area.rect.h == 256 ? "crtpi_256.glsl" : "crtpi_240.glsl";
std::ifstream f(Asset::get()->get(GLSL_FILE).c_str());
shader_source_ = std::string((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
auto data = Asset::get()->loadData(GLSL_FILE);
if (!data.empty()) {
shader_source_ = std::string(data.begin(), data.end());
}
}
}

12
source/sections/game.cpp
View File

@@ -606,6 +606,7 @@ void Game::handleItemDrop(const std::shared_ptr<Balloon> &balloon, const std::sh
if (DROPPED_ITEM != ItemType::COFFEE_MACHINE) {
createItem(DROPPED_ITEM, balloon->getPosX(), balloon->getPosY());
playSound("item_drop.wav");
} else {
createItem(DROPPED_ITEM, player->getPosX(), param.game.game_area.rect.y - Item::COFFEE_MACHINE_HEIGHT);
coffee_machine_enabled_ = true;
@@ -733,7 +734,6 @@ auto Game::dropItem() -> ItemType {
// Crea un objeto item
void Game::createItem(ItemType type, float x, float y) {
items_.emplace_back(std::make_unique<Item>(type, x, y, param.game.play_area.rect, item_textures_[static_cast<int>(type) - 1], item_animations_[static_cast<int>(type) - 1]));
playSound("item_drop.wav");
}
// Vacia el vector de items
@@ -1424,9 +1424,11 @@ void Game::handleNameInput(const std::shared_ptr<Player> &player) {
} else if (player->getEnterNamePositionOverflow()) {
player->setInput(Input::Action::START);
player->setPlayingState(Player::State::SHOWING_NAME);
playSound("service_menu_select.wav");
updateHiScoreName();
} else {
player->setInput(Input::Action::RIGHT);
playSound("service_menu_select.wav");
}
} else if (input_->checkAction(Input::Action::FIRE_CENTER, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad()) ||
input_->checkAction(Input::Action::FIRE_RIGHT, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
@@ -1434,17 +1436,21 @@ void Game::handleNameInput(const std::shared_ptr<Player> &player) {
player->setPlayingState(Player::State::CONTINUE);
} else {
player->setInput(Input::Action::LEFT);
playSound("service_menu_back.wav");
}
} else if (input_->checkAction(Input::Action::UP, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
player->setInput(Input::Action::UP);
} else if (input_->checkAction(Input::Action::DOWN, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
player->setInput(Input::Action::DOWN);
playSound("service_menu_move.wav");
} else if (input_->checkAction(Input::Action::DOWN, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
player->setInput(Input::Action::DOWN);
playSound("service_menu_move.wav");
} else if (input_->checkAction(Input::Action::START, Input::DO_NOT_ALLOW_REPEAT, player->getUsesKeyboard(), player->getGamepad())) {
if (player->isShowingName()) {
player->setPlayingState(Player::State::CONTINUE);
} else {
player->setInput(Input::Action::START);
player->setPlayingState(Player::State::SHOWING_NAME);
playSound("service_menu_select.wav");
updateHiScoreName();
}
}

40
source/text.cpp
View File

@@ -4,6 +4,7 @@
#include <fstream> // Para basic_ifstream, basic_istream, basic_ostream, operator<<, endl, ifstream
#include <iostream> // Para cerr
#include <sstream> // Para istringstream
#include <stdexcept> // Para runtime_error
#include <string_view> // Para string_view
@@ -12,6 +13,7 @@
#include "sprite.h" // Para Sprite
#include "texture.h" // Para Texture
#include "utils.h" // Para getFileName, printWithDots
#include "resource_helper.h" // Para ResourceHelper
// Constructor
Text::Text(const std::shared_ptr<Texture> &texture, const std::string &text_file) {
@@ -372,25 +374,41 @@ auto Text::loadFile(const std::string &file_path) -> std::shared_ptr<Text::File>
tf->box_height = 0;
}
// Abre el fichero para leer los valores
std::ifstream file(file_path);
// Intenta cargar desde ResourceHelper primero
auto resource_data = ResourceHelper::loadFile(file_path);
std::istringstream stream;
bool using_resource_data = false;
if (!resource_data.empty()) {
std::string content(resource_data.begin(), resource_data.end());
stream.str(content);
using_resource_data = true;
}
// Fallback a archivo directo
std::ifstream file;
if (!using_resource_data) {
file.open(file_path);
}
std::istream& input_stream = using_resource_data ? stream : static_cast<std::istream&>(file);
if (file.is_open() && file.good()) {
if ((using_resource_data && stream.good()) || (!using_resource_data && file.is_open() && file.good())) {
std::string buffer;
// Lee los dos primeros valores del fichero
std::getline(file, buffer);
std::getline(file, buffer);
std::getline(input_stream, buffer);
std::getline(input_stream, buffer);
tf->box_width = std::stoi(buffer);
std::getline(file, buffer);
std::getline(file, buffer);
std::getline(input_stream, buffer);
std::getline(input_stream, buffer);
tf->box_height = std::stoi(buffer);
// lee el resto de datos del fichero
auto index = 32;
auto line_read = 0;
while (std::getline(file, buffer)) {
while (std::getline(input_stream, buffer)) {
// Almacena solo las lineas impares
if (line_read % 2 == 1) {
tf->offset[index++].w = std::stoi(buffer);
@@ -401,9 +419,11 @@ auto Text::loadFile(const std::string &file_path) -> std::shared_ptr<Text::File>
line_read++;
};
// Cierra el fichero
// Cierra el fichero si se usó
printWithDots("Text File : ", getFileName(file_path), "[ LOADED ]");
file.close();
if (!using_resource_data && file.is_open()) {
file.close();
}
}
// El fichero no se puede abrir

119
source/texture.cpp
View File

@@ -16,6 +16,7 @@
#include "external/gif.h" // Para Gif
#include "stb_image.h" // Para stbi_image_free, stbi_load, STBI_rgb_alpha
#include "utils.h"
#include "resource_helper.h" // Para ResourceHelper
// Constructor
Texture::Texture(SDL_Renderer *renderer, std::string path)
@@ -64,7 +65,19 @@ auto Texture::loadFromFile(const std::string &file_path) -> bool {
int width;
int height;
int orig_format;
unsigned char *data = stbi_load(file_path.c_str(), &width, &height, &orig_format, req_format);
unsigned char *data = nullptr;
// Intentar cargar desde ResourceHelper primero
auto resource_data = ResourceHelper::loadFile(file_path);
if (!resource_data.empty()) {
data = stbi_load_from_memory(resource_data.data(), resource_data.size(), &width, &height, &orig_format, req_format);
}
// Fallback a filesystem directo
if (data == nullptr) {
data = stbi_load(file_path.c_str(), &width, &height, &orig_format, req_format);
}
if (data == nullptr) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", getFileName(file_path).c_str());
throw std::runtime_error("Fichero no encontrado: " + getFileName(file_path));
@@ -212,22 +225,30 @@ auto Texture::loadSurface(const std::string &file_path) -> std::shared_ptr<Surfa
// Libera la superficie actual
unloadSurface();
// Abrir el archivo usando std::ifstream para manejo automático del recurso
std::ifstream file(file_path, std::ios::binary | std::ios::ate);
if (!file) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
throw std::runtime_error("Fichero no encontrado: " + file_path);
}
std::vector<Uint8> buffer;
// Intentar cargar desde ResourceHelper primero
auto resource_data = ResourceHelper::loadFile(file_path);
if (!resource_data.empty()) {
buffer = resource_data;
} else {
// Fallback a filesystem directo
std::ifstream file(file_path, std::ios::binary | std::ios::ate);
if (!file) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
throw std::runtime_error("Fichero no encontrado: " + file_path);
}
// Obtener el tamaño del archivo
std::streamsize size = file.tellg();
file.seekg(0, std::ios::beg);
// Obtener el tamaño del archivo
std::streamsize size = file.tellg();
file.seekg(0, std::ios::beg);
// Leer el contenido del archivo en un buffer
std::vector<Uint8> buffer(size);
if (!file.read(reinterpret_cast<char *>(buffer.data()), size)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error al leer el fichero %s", file_path.c_str());
throw std::runtime_error("Error al leer el fichero: " + file_path);
// Leer el contenido del archivo en un buffer
buffer.resize(size);
if (!file.read(reinterpret_cast<char *>(buffer.data()), size)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error al leer el fichero %s", file_path.c_str());
throw std::runtime_error("Error al leer el fichero: " + file_path);
}
}
// Crear un objeto Gif y llamar a la función loadGif
@@ -283,24 +304,33 @@ void Texture::setPaletteColor(int palette, int index, Uint32 color) {
auto Texture::loadPaletteFromFile(const std::string &file_path) -> Palette {
Palette palette;
// Abrir el archivo GIF
std::ifstream file(file_path, std::ios::binary | std::ios::ate);
if (!file) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
throw std::runtime_error("Fichero no encontrado: " + file_path);
std::vector<Uint8> buffer;
// Intentar cargar desde ResourceHelper primero
auto resource_data = ResourceHelper::loadFile(file_path);
if (!resource_data.empty()) {
buffer = resource_data;
} else {
// Fallback a filesystem directo
std::ifstream file(file_path, std::ios::binary | std::ios::ate);
if (!file) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
throw std::runtime_error("Fichero no encontrado: " + file_path);
}
// Obtener el tamaño del archivo y leerlo en un buffer
std::streamsize size = file.tellg();
file.seekg(0, std::ios::beg);
buffer.resize(size);
if (!file.read(reinterpret_cast<char *>(buffer.data()), size)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: No se pudo leer completamente el fichero %s", file_path.c_str());
throw std::runtime_error("Error al leer el fichero: " + file_path);
}
}
printWithDots("Palette : ", getFileName(file_path), "[ LOADED ]");
// Obtener el tamaño del archivo y leerlo en un buffer
std::streamsize size = file.tellg();
file.seekg(0, std::ios::beg);
std::vector<Uint8> buffer(size);
if (!file.read(reinterpret_cast<char *>(buffer.data()), size)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: No se pudo leer completamente el fichero %s", file_path.c_str());
throw std::runtime_error("Error al leer el fichero: " + file_path);
}
// Usar la nueva función loadPalette, que devuelve un vector<uint32_t>
GIF::Gif gif;
std::vector<uint32_t> pal = gif.loadPalette(buffer.data());
@@ -346,16 +376,33 @@ auto Texture::readPalFile(const std::string &file_path) -> Palette {
Palette palette{};
palette.fill(0); // Inicializar todo con 0 (transparente por defecto)
std::ifstream file(file_path);
if (!file.is_open()) {
throw std::runtime_error("No se pudo abrir el archivo .pal");
// Intentar cargar desde ResourceHelper primero
auto resource_data = ResourceHelper::loadFile(file_path);
std::istringstream stream;
bool using_resource_data = false;
if (!resource_data.empty()) {
std::string content(resource_data.begin(), resource_data.end());
stream.str(content);
using_resource_data = true;
}
// Fallback a archivo directo
std::ifstream file;
if (!using_resource_data) {
file.open(file_path);
if (!file.is_open()) {
throw std::runtime_error("No se pudo abrir el archivo .pal");
}
}
std::istream& input_stream = using_resource_data ? stream : static_cast<std::istream&>(file);
std::string line;
int line_number = 0;
int color_index = 0;
while (std::getline(file, line)) {
while (std::getline(input_stream, line)) {
++line_number;
// Ignorar las tres primeras líneas del archivo
@@ -380,6 +427,8 @@ auto Texture::readPalFile(const std::string &file_path) -> Palette {
}
}
file.close();
if (!using_resource_data && file.is_open()) {
file.close();
}
return palette;
}

7
source/ui/service_menu.cpp
View File

@@ -49,16 +49,17 @@ void ServiceMenu::toggle() {
return;
}
playBackSound();
if (!enabled_) { // Si está cerrado, abrir
reset();
Options::gamepad_manager.assignAndLinkGamepads();
renderer_->show(this);
setEnabledInternal(true);
playSelectSound();
} else { // Si está abierto, cerrar
renderer_->hide();
setEnabledInternal(false);
playBackSound();
}
}
@@ -518,7 +519,7 @@ void ServiceMenu::adjustListValues() {
void ServiceMenu::playAdjustSound() { Audio::get()->playSound("service_menu_adjust.wav", Audio::Group::INTERFACE); }
void ServiceMenu::playMoveSound() { Audio::get()->playSound("service_menu_move.wav", Audio::Group::INTERFACE); }
void ServiceMenu::playSelectSound() { Audio::get()->playSound("service_menu_select.wav", Audio::Group::INTERFACE); }
void ServiceMenu::playBackSound() { Audio::get()->playSound("service_menu_select.wav", Audio::Group::INTERFACE); }
void ServiceMenu::playBackSound() { Audio::get()->playSound("service_menu_back.wav", Audio::Group::INTERFACE); }
// Devuelve el nombre del grupo como string para el título
auto ServiceMenu::settingsGroupToString(SettingsGroup group) -> std::string {

14
source/utils.cpp
View File

@@ -13,6 +13,7 @@
#include <string> // Para basic_string, allocator, string, operator==, operator+, char_traits
#include "lang.h" // Para getText
#include "resource_helper.h" // Para ResourceHelper
// Variables
Overrides overrides = Overrides();
@@ -323,8 +324,17 @@ void printWithDots(const std::string &text1, const std::string &text2, const std
auto loadDemoDataFromFile(const std::string &file_path) -> DemoData {
DemoData dd;
// Indicador de éxito en la carga
auto *file = SDL_IOFromFile(file_path.c_str(), "r+b");
SDL_IOStream *file = nullptr;
// Intentar cargar desde ResourceHelper primero
auto resource_data = ResourceHelper::loadFile(file_path);
if (!resource_data.empty()) {
file = SDL_IOFromConstMem(resource_data.data(), resource_data.size());
} else {
// Fallback a filesystem directo
file = SDL_IOFromFile(file_path.c_str(), "r+b");
}
if (file == nullptr) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
throw std::runtime_error("Fichero no encontrado: " + file_path);

77
tools/Makefile Normal file
View File

@@ -0,0 +1,77 @@
# Makefile para herramientas de Coffee Crisis Arcade Edition
# =========================================================
# Variables
CXX := g++
CXXFLAGS := -std=c++17 -Wall -Os -I../
SOURCES := pack_resources.cpp ../source/resource_pack.cpp
TARGET := pack_resources
CLEAN_FILES := pack_resources *.pack *.o
# Detectar sistema operativo
ifeq ($(OS),Windows_NT)
DETECTED_OS := Windows
TARGET := $(TARGET).exe
CLEAN_CMD := del /Q
FixPath = $(subst /,\\,$1)
else
DETECTED_OS := $(shell uname -s)
CLEAN_CMD := rm -f
FixPath = $1
endif
# Reglas principales
.PHONY: all pack_tool clean help test_pack
# Compilar herramienta de empaquetado
all: pack_tool
pack_tool:
@echo "Compilando herramienta de empaquetado para $(DETECTED_OS)..."
$(CXX) $(CXXFLAGS) $(SOURCES) -o $(TARGET)
@echo "✓ Herramienta compilada: $(TARGET)"
# Limpiar archivos generados
clean:
@echo "Limpiando archivos generados..."
$(CLEAN_CMD) $(call FixPath,$(CLEAN_FILES))
@echo "✓ Archivos limpiados"
# Crear pack de recursos de prueba
test_pack: pack_tool
@echo "Creando pack de recursos de prueba..."
ifeq ($(OS),Windows_NT)
.\$(TARGET) ..\data test_resources.pack
else
./$(TARGET) ../data test_resources.pack
endif
@echo "✓ Pack de prueba creado: test_resources.pack"
# Crear pack de recursos final
create_pack: pack_tool
@echo "Creando pack de recursos final..."
ifeq ($(OS),Windows_NT)
.\$(TARGET) ..\data ..\resources.pack
else
./$(TARGET) ../data ../resources.pack
endif
@echo "✓ Pack final creado: ../resources.pack"
# Mostrar ayuda
help:
@echo "Makefile para herramientas de Coffee Crisis Arcade Edition"
@echo "========================================================="
@echo ""
@echo "Comandos disponibles:"
@echo " all - Compilar herramienta de empaquetado (por defecto)"
@echo " pack_tool - Compilar herramienta de empaquetado"
@echo " test_pack - Crear pack de recursos de prueba"
@echo " create_pack - Crear pack de recursos final"
@echo " clean - Limpiar archivos generados"
@echo " help - Mostrar esta ayuda"
@echo ""
@echo "Ejemplos de uso:"
@echo " make # Compilar herramienta"
@echo " make test_pack # Crear pack de prueba"
@echo " make create_pack # Crear pack final"
@echo " make clean # Limpiar archivos"

151
tools/README.md Normal file
View File

@@ -0,0 +1,151 @@
# Coffee Crisis Arcade Edition - Herramientas de Recursos
Este directorio contiene herramientas para empaquetar los recursos del juego en un archivo único y ofuscado.
## 📁 Archivos
- **`pack_resources.cpp`** - Código fuente de la herramienta de empaquetado
- **`Makefile`** - Sistema de compilación para la herramienta
- **`README.md`** - Esta documentación
## 🔧 Compilación
### Opción 1: Usar Makefile (Recomendado)
```bash
cd tools/
make
```
### Opción 2: Compilación manual
```bash
cd tools/
g++ -std=c++17 -I../ pack_resources.cpp ../source/resource_pack.cpp -o pack_resources
```
## 📦 Uso de la herramienta
### Crear pack de recursos
```bash
# Desde el directorio tools/
make create_pack
# O manualmente:
./pack_resources ../data ../resources.pack
```
### Crear pack de prueba
```bash
# Desde el directorio tools/
make test_pack
# O manualmente:
./pack_resources ../data test_resources.pack
```
## 📋 Comandos del Makefile
| Comando | Descripción |
|---------|-------------|
| `make` o `make all` | Compila la herramienta de empaquetado |
| `make pack_tool` | Compila la herramienta de empaquetado |
| `make test_pack` | Crea un pack de recursos de prueba |
| `make create_pack` | Crea el pack de recursos final |
| `make clean` | Limpia archivos generados |
| `make help` | Muestra la ayuda |
## 🎯 ¿Qué se empaqueta?
La herramienta empaqueta **solo** el contenido del directorio `data/`:
```
data/
├── font/ ✅ Empaquetado
├── gfx/ ✅ Empaquetado
├── lang/ ✅ Empaquetado
├── music/ ✅ Empaquetado
├── shaders/ ✅ Empaquetado
└── sound/ ✅ Empaquetado
```
**NO se empaqueta:**
- `config/` - Archivos de configuración (quedan accesibles)
- Archivos de sistema
## 🔐 Características del pack
- **Formato binario personalizado** con cabecera "CCAE"
- **Encriptación XOR** simple para ofuscar contenido
- **Checksums** para verificar integridad
- **Compresión** por concatenación de archivos
- **Tamaño típico:** ~10MB para todos los recursos
## 🚀 Integración en el juego
El juego automáticamente detecta si existe `resources.pack`:
1. **Con pack:** Carga recursos del archivo empaquetado
2. **Sin pack:** Carga recursos desde `data/` (modo desarrollo)
Para habilitar el sistema de packs, descomenta en `source/director.cpp:82`:
```cpp
ResourceHelper::initializeResourceSystem("resources.pack");
```
## 📝 Ejemplo completo
```bash
# 1. Ir al directorio tools
cd tools/
# 2. Compilar herramienta
make
# 3. Crear pack final
make create_pack
# 4. El juego ahora usará resources.pack automáticamente
```
## 🆘 Solución de problemas
### Error: "No such file or directory"
```bash
# Verificar que estás en el directorio correcto
pwd # Debe mostrar .../coffee_crisis_arcade_edition/tools
# Verificar que existe el directorio data
ls ../data
```
### Error de compilación
```bash
# Limpiar y recompilar
make clean
make
```
### El juego no encuentra los recursos
```bash
# Verificar que resources.pack está en el directorio raíz del juego
ls ../resources.pack
# Verificar el tamaño del pack (debe ser ~10MB)
ls -lh ../resources.pack
```
## 📊 Información técnica
- **Archivos empaquetados:** ~148 recursos
- **Tamaño sin comprimir:** ~15MB de recursos individuales
- **Tamaño empaquetado:** ~10MB (reducción del 33%)
- **Tiempo de empaquetado:** < 1 segundo
- **Compatibilidad:** Windows, Linux, macOS
---
**Nota:** Los archivos de configuración en `config/` permanecen accesibles para permitir modificaciones por parte del usuario.

BIN
tools/pack_resources Executable file
View File

Binary file not shown.

106
tools/pack_resources.cpp Normal file
View File

@@ -0,0 +1,106 @@
#include "../source/resource_pack.h"
#include <iostream>
#include <filesystem>
void showHelp() {
std::cout << "Coffee Crisis Arcade Edition - Resource Packer" << std::endl;
std::cout << "===============================================" << std::endl;
std::cout << "Usage: pack_resources [options] [input_dir] [output_file]" << std::endl;
std::cout << std::endl;
std::cout << "Options:" << std::endl;
std::cout << " --help Show this help message" << std::endl;
std::cout << " --list List contents of an existing pack file" << std::endl;
std::cout << std::endl;
std::cout << "Arguments:" << std::endl;
std::cout << " input_dir Directory to pack (default: data)" << std::endl;
std::cout << " output_file Pack file name (default: resources.pack)" << std::endl;
std::cout << std::endl;
std::cout << "Examples:" << std::endl;
std::cout << " pack_resources # Pack 'data' to 'resources.pack'" << std::endl;
std::cout << " pack_resources mydata # Pack 'mydata' to 'resources.pack'" << std::endl;
std::cout << " pack_resources data my.pack # Pack 'data' to 'my.pack'" << std::endl;
std::cout << " pack_resources --list my.pack # List contents of 'my.pack'" << std::endl;
}
void listPackContents(const std::string& packFile) {
ResourcePack pack;
if (!pack.loadPack(packFile)) {
std::cerr << "Error: Cannot open pack file: " << packFile << std::endl;
return;
}
auto resources = pack.getResourceList();
std::cout << "Pack file: " << packFile << std::endl;
std::cout << "Resources: " << resources.size() << std::endl;
std::cout << "Contents:" << std::endl;
for (const auto& resource : resources) {
std::cout << " " << resource << std::endl;
}
}
int main(int argc, char* argv[]) {
std::string dataDir = "data";
std::string outputFile = "resources.pack";
bool listMode = false;
// Parse arguments
for (int i = 1; i < argc; i++) {
std::string arg = argv[i];
if (arg == "--help" || arg == "-h") {
showHelp();
return 0;
} else if (arg == "--list") {
listMode = true;
if (i + 1 < argc) {
outputFile = argv[++i]; // Next argument is pack file to list
}
} else if (!arg.empty() && arg[0] != '-') {
if (dataDir == "data") {
dataDir = arg;
} else {
outputFile = arg;
}
}
}
if (listMode) {
listPackContents(outputFile);
return 0;
}
std::cout << "Coffee Crisis Arcade Edition - Resource Packer" << std::endl;
std::cout << "===============================================" << std::endl;
std::cout << "Input directory: " << dataDir << std::endl;
std::cout << "Output file: " << outputFile << std::endl;
std::cout << std::endl;
if (!std::filesystem::exists(dataDir)) {
std::cerr << "Error: Input directory does not exist: " << dataDir << std::endl;
return 1;
}
ResourcePack pack;
std::cout << "Scanning and packing resources..." << std::endl;
if (!pack.addDirectory(dataDir)) {
std::cerr << "Error: Failed to add directory to pack" << std::endl;
return 1;
}
std::cout << "Found " << pack.getResourceCount() << " resources" << std::endl;
std::cout << "Saving pack file..." << std::endl;
if (!pack.savePack(outputFile)) {
std::cerr << "Error: Failed to save pack file" << std::endl;
return 1;
}
std::filesystem::path packPath(outputFile);
auto fileSize = std::filesystem::file_size(packPath);
std::cout << "Pack file created successfully!" << std::endl;
std::cout << "File size: " << (fileSize / 1024.0 / 1024.0) << " MB" << std::endl;
return 0;
}