297 lines
10 KiB
C++
297 lines
10 KiB
C++
// resource_pack.cpp - Implementació del sistema de empaquetament
|
|
// © 2026 JailDesigner
|
|
|
|
#include "resource_pack.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
|
|
namespace Resource {
|
|
|
|
// Calcular checksum CRC32 simplificat
|
|
auto Pack::calculateChecksum(const std::vector<uint8_t>& data) -> uint32_t {
|
|
uint32_t checksum = 0x12345678;
|
|
for (unsigned char byte : data) {
|
|
checksum = ((checksum << 5) + checksum) + byte;
|
|
}
|
|
return checksum;
|
|
}
|
|
|
|
// Encriptació XOR (simètrica)
|
|
void Pack::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 Pack::decryptData(std::vector<uint8_t>& data, const std::string& key) {
|
|
// XOR es simètric
|
|
encryptData(data, key);
|
|
}
|
|
|
|
// Llegir file complet a memòria
|
|
auto Pack::readFile(const std::string& filepath) -> std::vector<uint8_t> {
|
|
std::ifstream file(filepath, std::ios::binary | std::ios::ate);
|
|
if (!file) {
|
|
std::cerr << "[ResourcePack] Error: no es pot obrir " << filepath << '\n';
|
|
return {};
|
|
}
|
|
|
|
std::streamsize file_size = file.tellg();
|
|
file.seekg(0, std::ios::beg);
|
|
|
|
std::vector<uint8_t> data(file_size);
|
|
if (!file.read(reinterpret_cast<char*>(data.data()), file_size)) {
|
|
std::cerr << "[ResourcePack] Error: no es pot llegir " << filepath << '\n';
|
|
return {};
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
// Añadir un file individual al paquet
|
|
auto Pack::addFile(const std::string& filepath, const std::string& pack_name) -> bool {
|
|
auto file_data = readFile(filepath);
|
|
if (file_data.empty()) {
|
|
return false;
|
|
}
|
|
|
|
ResourceEntry entry{
|
|
.filename = pack_name,
|
|
.offset = data_.size(),
|
|
.size = file_data.size(),
|
|
.checksum = calculateChecksum(file_data)};
|
|
|
|
// Añadir dades al bloc de dades
|
|
data_.insert(data_.end(), file_data.begin(), file_data.end());
|
|
|
|
resources_[pack_name] = entry;
|
|
|
|
return true;
|
|
}
|
|
|
|
// Añadir todos los archivos de un directori recursivament
|
|
auto Pack::addDirectory(const std::string& dir_path,
|
|
const std::string& base_path) -> bool {
|
|
namespace fs = std::filesystem;
|
|
|
|
if (!fs::exists(dir_path) || !fs::is_directory(dir_path)) {
|
|
std::cerr << "[ResourcePack] Error: directori no trobat: " << dir_path << '\n';
|
|
return false;
|
|
}
|
|
|
|
std::string current_base = base_path.empty() ? "" : base_path + "/";
|
|
|
|
for (const auto& entry : fs::recursive_directory_iterator(dir_path)) {
|
|
if (!entry.is_regular_file()) {
|
|
continue;
|
|
}
|
|
|
|
std::string full_path = entry.path().string();
|
|
std::string relative_path = entry.path().lexically_relative(dir_path).string();
|
|
|
|
// Convertir barres invertides a normals (Windows)
|
|
std::ranges::replace(relative_path, '\\', '/');
|
|
|
|
// Saltar archivos de desenvolupament
|
|
if (relative_path.find(".world") != std::string::npos ||
|
|
relative_path.find(".tsx") != std::string::npos ||
|
|
relative_path.find(".DS_Store") != std::string::npos ||
|
|
relative_path.find(".git") != std::string::npos) {
|
|
continue;
|
|
}
|
|
|
|
std::string pack_name = current_base + relative_path;
|
|
addFile(full_path, pack_name);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Guardar paquet a disc
|
|
auto Pack::savePack(const std::string& pack_file) -> bool {
|
|
std::ofstream file(pack_file, std::ios::binary);
|
|
if (!file) {
|
|
std::cerr << "[ResourcePack] Error: no es pot crear " << pack_file << '\n';
|
|
return false;
|
|
}
|
|
|
|
// Escriure capçalera
|
|
file.write(MAGIC_HEADER, 4);
|
|
file.write(reinterpret_cast<const char*>(&VERSION), sizeof(VERSION));
|
|
|
|
// Escriure nombre de recursos
|
|
auto resource_count = static_cast<uint32_t>(resources_.size());
|
|
file.write(reinterpret_cast<const char*>(&resource_count), sizeof(resource_count));
|
|
|
|
// Escriure metadades de recursos
|
|
for (const auto& [name, entry] : resources_) {
|
|
// Nom del file
|
|
auto name_len = static_cast<uint32_t>(entry.filename.length());
|
|
file.write(reinterpret_cast<const char*>(&name_len), sizeof(name_len));
|
|
file.write(entry.filename.c_str(), name_len);
|
|
|
|
// Offset, mida, checksum
|
|
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));
|
|
}
|
|
|
|
// Encriptar dades
|
|
std::vector<uint8_t> encrypted_data = data_;
|
|
encryptData(encrypted_data, DEFAULT_ENCRYPT_KEY);
|
|
|
|
// Escriure mida de dades y dades encriptades
|
|
auto data_size = static_cast<uint64_t>(encrypted_data.size());
|
|
file.write(reinterpret_cast<const char*>(&data_size), sizeof(data_size));
|
|
file.write(reinterpret_cast<const char*>(encrypted_data.data()), encrypted_data.size());
|
|
|
|
return true;
|
|
}
|
|
|
|
// Carregar paquet desde disc
|
|
auto Pack::loadPack(const std::string& pack_file) -> bool {
|
|
std::ifstream file(pack_file, std::ios::binary);
|
|
if (!file) {
|
|
std::cerr << "[ResourcePack] Error: no es pot obrir " << pack_file << '\n';
|
|
return false;
|
|
}
|
|
|
|
// Llegir capçalera
|
|
char magic[4];
|
|
file.read(magic, 4);
|
|
if (std::string(magic, 4) != MAGIC_HEADER) {
|
|
std::cerr << "[ResourcePack] Error: capçalera invàlida (esperava " << MAGIC_HEADER
|
|
<< ")\n";
|
|
return false;
|
|
}
|
|
|
|
uint32_t version;
|
|
file.read(reinterpret_cast<char*>(&version), sizeof(version));
|
|
if (version != VERSION) {
|
|
std::cerr << "[ResourcePack] Error: versión incompatible (esperava " << VERSION
|
|
<< ", trobat " << version << ")\n";
|
|
return false;
|
|
}
|
|
|
|
// Llegir nombre de recursos
|
|
uint32_t resource_count;
|
|
file.read(reinterpret_cast<char*>(&resource_count), sizeof(resource_count));
|
|
|
|
// Llegir metadades de recursos
|
|
resources_.clear();
|
|
for (uint32_t i = 0; i < resource_count; ++i) {
|
|
// Nom del file
|
|
uint32_t name_len;
|
|
file.read(reinterpret_cast<char*>(&name_len), sizeof(name_len));
|
|
|
|
std::string filename(name_len, '\0');
|
|
file.read(filename.data(), name_len);
|
|
|
|
// Offset, mida, checksum
|
|
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;
|
|
}
|
|
|
|
// Llegir dades encriptades
|
|
uint64_t data_size;
|
|
file.read(reinterpret_cast<char*>(&data_size), sizeof(data_size));
|
|
|
|
data_.resize(data_size);
|
|
file.read(reinterpret_cast<char*>(data_.data()), data_size);
|
|
|
|
// Desencriptar
|
|
decryptData(data_, DEFAULT_ENCRYPT_KEY);
|
|
|
|
return true;
|
|
}
|
|
|
|
// Obtenir un recurs del paquet
|
|
auto Pack::getResource(const std::string& filename) -> std::vector<uint8_t> {
|
|
auto it = resources_.find(filename);
|
|
if (it == resources_.end()) {
|
|
std::cerr << "[ResourcePack] Error: recurs no trobat: " << filename << '\n';
|
|
return {};
|
|
}
|
|
|
|
const auto& entry = it->second;
|
|
|
|
// Extreure dades
|
|
if (entry.offset + entry.size > data_.size()) {
|
|
std::cerr << "[ResourcePack] Error: offset/mida invàlid per " << filename << '\n';
|
|
return {};
|
|
}
|
|
|
|
std::vector<uint8_t> resource_data(data_.begin() + entry.offset,
|
|
data_.begin() + entry.offset + entry.size);
|
|
|
|
// Verificar checksum
|
|
uint32_t computed_checksum = calculateChecksum(resource_data);
|
|
if (computed_checksum != entry.checksum) {
|
|
std::cerr << "[ResourcePack] ADVERTÈNCIA: checksum invàlid per " << filename
|
|
<< " (esperat " << entry.checksum << ", calculat " << computed_checksum
|
|
<< ")\n";
|
|
// No falla, pero adverteix
|
|
}
|
|
|
|
return resource_data;
|
|
}
|
|
|
|
// Comprovar si existeix un recurs
|
|
auto Pack::hasResource(const std::string& filename) const -> bool {
|
|
return resources_.contains(filename);
|
|
}
|
|
|
|
// Obtenir list de todos los recursos
|
|
auto Pack::getResourceList() const -> std::vector<std::string> {
|
|
std::vector<std::string> list;
|
|
list.reserve(resources_.size());
|
|
|
|
for (const auto& [name, entry] : resources_) {
|
|
list.push_back(name);
|
|
}
|
|
|
|
std::ranges::sort(list);
|
|
return list;
|
|
}
|
|
|
|
// Validar integritat del paquet
|
|
auto Pack::validatePack() const -> bool {
|
|
bool valid = true;
|
|
|
|
for (const auto& [name, entry] : resources_) {
|
|
// Verificar offset i mida
|
|
if (entry.offset + entry.size > data_.size()) {
|
|
std::cerr << "[ResourcePack] Error de validació: " << name
|
|
<< " té offset/mida invàlid\n";
|
|
valid = false;
|
|
continue;
|
|
}
|
|
|
|
// Extreure i verificar checksum
|
|
std::vector<uint8_t> resource_data(data_.begin() + entry.offset,
|
|
data_.begin() + entry.offset + entry.size);
|
|
|
|
uint32_t computed_checksum = calculateChecksum(resource_data);
|
|
if (computed_checksum != entry.checksum) {
|
|
std::cerr << "[ResourcePack] Error de validació: " << name
|
|
<< " té checksum invàlid\n";
|
|
valid = false;
|
|
}
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
|
|
} // namespace Resource
|