afegit resources.pack y prefixe a les rutes de recursos

2025-12-08 21:48:52 +01:00
parent 4b7cbd88bb
commit a41e696b69
21 changed files with 1066 additions and 36 deletions
@@ -0,0 +1,309 @@
+// resource_pack.cpp - Implementació del sistema d'empaquetament
+// © 2025 Port a C++20 amb SDL3
+
+#include "resource_pack.hpp"
+
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
+namespace Resource {
+
+// Calcular checksum CRC32 simplificat
+uint32_t Pack::calculateChecksum(const std::vector<uint8_t>& data) const {
+    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 és simètric
+    encryptData(data, key);
+}
+
+// Llegir fitxer complet a memòria
+std::vector<uint8_t> Pack::readFile(const std::string& filepath) {
+    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;
+}
+
+// Afegir un fitxer individual al paquet
+bool Pack::addFile(const std::string& filepath, const std::string& pack_name) {
+    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)};
+
+    // Afegir dades al bloc de dades
+    data_.insert(data_.end(), file_data.begin(), file_data.end());
+
+    resources_[pack_name] = entry;
+
+    std::cout << "[ResourcePack] Afegit: " << pack_name << " (" << file_data.size()
+              << " bytes)\n";
+    return true;
+}
+
+// Afegir tots els fitxers d'un directori recursivament
+bool Pack::addDirectory(const std::string& dir_path,
+    const std::string& base_path) {
+    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 fitxers 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) {
+            std::cout << "[ResourcePack] Saltant: " << relative_path << '\n';
+            continue;
+        }
+
+        std::string pack_name = current_base + relative_path;
+        addFile(full_path, pack_name);
+    }
+
+    return true;
+}
+
+// Guardar paquet a disc
+bool Pack::savePack(const std::string& pack_file) {
+    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 fitxer
+        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 i 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());
+
+    std::cout << "[ResourcePack] Guardat: " << pack_file << " (" << resources_.size()
+              << " recursos, " << data_size << " bytes)\n";
+
+    return true;
+}
+
+// Carregar paquet des de disc
+bool Pack::loadPack(const std::string& pack_file) {
+    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ó 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 fitxer
+        uint32_t name_len;
+        file.read(reinterpret_cast<char*>(&name_len), sizeof(name_len));
+
+        std::string filename(name_len, '\0');
+        file.read(&filename[0], 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);
+
+    std::cout << "[ResourcePack] Carregat: " << pack_file << " (" << resources_.size()
+              << " recursos)\n";
+
+    return true;
+}
+
+// Obtenir un recurs del paquet
+std::vector<uint8_t> Pack::getResource(const std::string& filename) {
+    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, però adverteix
+    }
+
+    return resource_data;
+}
+
+// Comprovar si existeix un recurs
+bool Pack::hasResource(const std::string& filename) const {
+    return resources_.find(filename) != resources_.end();
+}
+
+// Obtenir llista de tots els recursos
+std::vector<std::string> Pack::getResourceList() const {
+    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
+bool Pack::validatePack() const {
+    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;
+        }
+    }
+
+    if (valid) {
+        std::cout << "[ResourcePack] Validació OK (" << resources_.size() << " recursos)\n";
+    }
+
+    return valid;
+}
+
+}  // namespace Resource