pakman.cpp

#include <iostream>
#include <filesystem>
#include <string_view>
#include <algorithm>
#include <fstream>
#include <vector>
#include <string>

using recursive_directory_iterator = std::filesystem::recursive_directory_iterator;

#pragma pack(push, 1)
struct pak_header_t {
    char magic[4];
    uint32_t initial_file_header_offset;
    uint32_t file_count;
};

struct pak_file_header_t {
    char filename[52];
    uint32_t data_offset;
    uint32_t data_size;
    uint32_t data_size_2;
};
#pragma pack(pop)

void print_usage(char** argv) {
    std::cout << "pakman: Pack and unpack .PAK and .BIN files from Garfield (2004)" << std::endl;
    std::cout << "pakman: Usage: " << argv[0] << " [pack/unpack] [file type (pak/bin)] [input/output file]";
}

int main(int argc, char** argv) {
    if (argc != 4) {
        print_usage(argv);
        return 1;
    }

    std::string_view cmd = argv[1];
    std::string_view type = argv[2];
    std::string file = argv[3];

    if (type != "pak" && type != "bin") {
        print_usage(argv);
        return 1;
    }

    if (cmd == "pack") {
        if (type == "pak") {
            std::vector<pak_file_header_t> headers;

            std::string pak_name = file + ".pak";
            std::ofstream pak(pak_name, std::ios::binary);

            pak_header_t pak_header{ 0 };
            pak.write((char*)&pak_header, sizeof(pak_header_t));

            std::cout << "pakman: Generating file table and writing files..." << std::endl;
            int offset = sizeof(pak_header_t);
            for (const auto& dir_entry : recursive_directory_iterator(file)) {
                if (dir_entry.is_directory())
                    continue;

                std::string rel_path = dir_entry.path().lexically_relative(file).string();
                std::replace(rel_path.begin(), rel_path.end(), '\\', '/');

                uint32_t size = std::filesystem::file_size(dir_entry);
                pak_file_header_t& header = headers.emplace_back();

                memset(header.filename, 0, sizeof(header.filename));
                memcpy(header.filename, rel_path.c_str(), std::min<uint32_t>(rel_path.length(), 52));
                header.data_offset = offset;
                header.data_size = size;
                header.data_size_2 = size;

                std::ifstream file(dir_entry.path(), std::ios::binary);
                pak << file.rdbuf();
                file.close();

                offset += size + 16;
                int pad = offset % 8;
                offset -= pad;

                for (int i = 0; i < 16 - pad; i++)
                    pak << '\0';
            }

            std::cout << "pakman: Writing file table..." << std::endl;
            pak.write((char*)headers.data(), headers.size() * sizeof(pak_file_header_t));

            memcpy(pak_header.magic, "PACK", 4);
            pak_header.file_count = headers.size();
            pak_header.initial_file_header_offset = offset;

            std::cout << "pakman: Writing pak header..." << std::endl;
            pak.seekp(0);
            pak.write((char*)&pak_header, sizeof(pak_header_t));
            pak.close();

            std::cout << "pakman: Done! Saved to " << pak_name << "." << std::endl;
        }
        else if (type == "bin") {
            std::string bin_name = file + ".bin";
            std::ofstream bin(bin_name, std::ios::binary);

            std::cout << "pakman: Writing files..." << std::endl;

            for (const auto& dir_entry : recursive_directory_iterator(file)) {
                if (dir_entry.is_directory())
                    continue;

                std::string rel_path = dir_entry.path().lexically_relative(file).string();
                std::replace(rel_path.begin(), rel_path.end(), '\\', '/');

                uint32_t size = std::filesystem::file_size(dir_entry);

                std::ifstream file(dir_entry.path(), std::ios::binary);
                bin << file.rdbuf();
                file.close();
            }

            bin.close();
            std::cout << "pakman: Done! Saved to " << bin_name << "." << std::endl;
        }
    }
    else if (cmd == "unpack") {
        std::cout << "pakman: Unpacking " << file << "..." << std::endl;

        if (type == "pak") {
            std::ifstream pak(file.data(), std::ios::binary | std::ios::ate);
            size_t size = pak.tellg();
            pak.seekg(0);

            if (!pak.is_open()) {
                std::cout << "pakman: Failed to open " << file << "." << std::endl;
                return 1;
            }

            pak_header_t pak_header;
            pak.read((char*)&pak_header, sizeof(pak_header_t));

            for (uint32_t i = 0; i < pak_header.file_count; i++) {
                pak_file_header_t file_header;
                pak.seekg(pak_header.initial_file_header_offset + (i * sizeof(pak_file_header_t)));
                pak.read((char*)&file_header, sizeof(pak_file_header_t));

                std::cout << "pakman: Wrote " << file_header.filename << " (" << i + 1 << "/" << pak_header.file_count << ")" << std::endl;

                std::filesystem::path path = file.substr(0, file.find_last_of("."));
                path /= file_header.filename;
                try {
                    std::filesystem::path dir = path;
                    std::filesystem::create_directories(dir.remove_filename());
                }
                catch (...) {}

                std::ofstream file(path, std::ios::binary);

                std::vector<char> data(file_header.data_size);
                pak.seekg(file_header.data_offset);
                pak.read(data.data(), file_header.data_size);
                file.write(data.data(), file_header.data_size);
            }

            pak.close();
            std::cout << "pakman: Done!" << std::endl;
        }
        else if (type == "bin") {
            std::ifstream bin(file, std::ios::binary);

            if (!bin.is_open()) {
                std::cout << "pakman: Failed to open " << file << "." << std::endl;
                return 1;
            }

            // This is slow, but the files will be relatively small anyway.
            std::string str((std::istreambuf_iterator<char>(bin)), std::istreambuf_iterator<char>());

            size_t pos;
            while ((pos = str.find("VAGp")) != std::string::npos) {
                size_t end_pos = str.find("VAGp", 4);

                if (end_pos == std::string::npos)
                    end_pos = str.size();

                size_t size = end_pos - pos;
                std::string data = str.substr(pos, end_pos);
                const char* filename = data.data() + 0x20;

                std::filesystem::path path = file.substr(0, file.find_last_of("."));
                path /= filename;
                try {
                    std::filesystem::path dir = path;
                    std::filesystem::create_directories(dir.remove_filename());
                }
                catch (...) {}

                std::ofstream out(path, std::ios::binary);
                out.write(data.data(), size);
                out.close();

                std::cout << "pakman: Wrote " << filename << "..." << std::endl;
                str = str.substr(end_pos);
            }

            bin.close();
            std::cout << "pakman: Done!" << std::endl;
        }


    }
    else {
        print_usage(argv);
        return 1;
    }

    return 0;
}