clank/rodecomp
1
0
Fork 0
Code Issues Wiki Activity
rodecomp/Source/Archive/GPak.cpp
ragnarok-clanker d456e8f64a Initial rodecomp source snapshot
2026-10-24 00:35:19 +00:00

327 lines
9.7 KiB
C++
Raw Blame History

#include "Archive/GPak.h"
#include "Archive/PakCipher.h"
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <zlib.h>
namespace {
std::uint32_t Read32(const std::uint8_t* bytes) {
std::uint32_t value;
std::memcpy(&value, bytes, sizeof(value));
return value;
}
std::uint64_t Read64(const std::uint8_t* bytes) {
std::uint64_t value;
std::memcpy(&value, bytes, sizeof(value));
return value;
}
std::uint8_t SwapNibbles(std::uint8_t byte) {
return static_cast<std::uint8_t>((byte << 4) | (byte >> 4));
}
void InitializeEntries(std::vector<myGPack::PakEntry>& entries, std::uint32_t count) {
std::size_t previous = entries.size();
entries.resize(count);
for (std::size_t i = previous; i < entries.size(); ++i) {
// Original value-initialization clears the complete record before name setup.
std::memset(&entries[i], 0, sizeof(entries[i]));
entries[i].name.Assign("");
}
}
// OFFSET: 0x00658FC0
// FUNCTION: fn_05116
std::uint64_t ReadAuxiliaryIdentifier(const void* data, std::size_t size) {
if (size != 0) {
const auto* bytes = static_cast<const std::uint8_t*>(data);
if (bytes[0] <= 1) {
return Read64(bytes + 4);
}
}
return UINT64_MAX;
}
void SortEntries(std::vector<myGPack::PakEntry>& entries) {
std::sort(entries.begin(), entries.end(), [](const auto& first, const auto& second) {
return first.name < second.name;
});
}
}
// OFFSET: 0x00E555A0
// FUNCTION: fn_24306
CGPak::CGPak() : m_file(nullptr), m_version(0), m_entryCount(0), m_tableOffset(0), m_tableSize(0) {
this->Reset();
InitializeCriticalSection(&this->m_criticalSection);
}
// OFFSET: 0x00AE97D0
// FUNCTION: fn_18107
// OFFSET: 0x00AE98C0
// FUNCTION: fn_18109
CGPak::~CGPak() {
DeleteCriticalSection(&this->m_criticalSection);
}
// OFFSET: 0x00AEBC00
// FUNCTION: fn_18130
void CGPak::Reset() {
this->m_entries.clear();
this->m_scratch.clear();
this->m_file = nullptr;
this->m_version = 0;
this->m_entryCount = 0;
this->m_tableOffset = 0;
this->m_tableSize = 0;
}
// OFFSET: 0x00AEBDB0
// FUNCTION: fn_18132
bool CGPak::Open(CPakFile* file) {
if (!file) {
return false;
}
this->m_file = file;
const std::uint8_t* header = file->Read(0, 46);
if (std::memcmp(header, "Event Horizon", 14) == 0) {
this->m_version = Read32(header + 42);
this->m_entryCount = Read32(header + 38);
this->m_tableOffset = Read64(header + 30) + 46;
} else if (std::memcmp(header, "Master of Magic", 16) == 0) {
this->m_version = Read32(header + 42);
this->m_entryCount = Read32(header + 38) - Read32(header + 34) - 7;
this->m_tableOffset = static_cast<std::uint64_t>(Read32(header + 30)) + 46;
} else {
this->Reset();
return false;
}
bool loaded;
switch (this->m_version & 0xFF00) {
case 0x100:
loaded = this->ReadTableV1();
break;
case 0x200:
loaded = this->ReadTableV2();
break;
case 0x300:
loaded = this->ReadTableV3();
break;
default:
loaded = false;
break;
}
if (loaded) {
return true;
}
this->Reset();
return false;
}
// OFFSET: 0x00AEC050
// FUNCTION: fn_18133
bool CGPak::ReadTableV1() {
this->m_tableSize =
static_cast<std::uint32_t>(this->m_file->GetSize()) - static_cast<std::uint32_t>(this->m_tableOffset);
const std::uint8_t* cursor = this->m_file->Read(this->m_tableOffset, this->m_tableSize);
InitializeEntries(this->m_entries, this->m_entryCount);
std::uint32_t maximum = 0;
std::uint32_t sequence = 1;
std::int32_t legacyKey = 95001;
for (std::uint32_t i = 0; i < this->m_entryCount; ++i) {
std::uint32_t nameSize = Read32(cursor);
cursor += 4;
char name[256];
if (this->m_version < 0x101) {
std::size_t length = std::strlen(reinterpret_cast<const char*>(cursor)) + 1;
for (std::size_t j = 0; j < length; ++j) {
name[j] = static_cast<char>(SwapNibbles(cursor[j]));
}
} else {
if (this->m_version > 0x103) {
return false;
}
cursor += 2;
std::int32_t length = static_cast<std::int32_t>(nameSize - 6);
for (std::int32_t j = 0; j < length; ++j) {
name[j] = static_cast<char>(SwapNibbles(cursor[j]));
}
std::int32_t number = legacyKey;
if (this->m_version != 0x101) {
number = static_cast<std::int32_t>(3 * (31669u - (sequence >> 1)));
}
if (number < 10000) {
number += 85000;
}
char digits[20];
_itoa(number, digits, 10);
std::uint8_t key[8];
key[0] = 'P';
key[1] = 'r';
std::memcpy(key + 2, digits, 5);
key[7] = 'e';
myGPack::PakCipher cipher(key);
std::uint8_t decoded[256];
int decodedLength;
cipher.Decode(reinterpret_cast<const std::uint8_t*>(name), length, decoded, &decodedLength, 1);
std::strcpy(name, reinterpret_cast<const char*>(decoded));
nameSize -= 2;
}
const std::uint8_t* metadata = cursor + nameSize;
cursor = metadata + 17;
myGPack::PakEntry& entry = this->m_entries[i];
entry.compressedSize = Read32(metadata) - Read32(metadata + 8) - 715;
entry.alignedSize = Read32(metadata + 4) - 37579;
entry.originalSize = Read32(metadata + 8);
entry.flags = metadata[12];
entry.dataOffset = Read32(metadata + 13);
entry.name.Assign(name);
const char* extension = std::strrchr(name, '.');
bool special = extension && (_stricmp(extension, ".gnd") == 0 || _stricmp(extension, ".gat") == 0 ||
_stricmp(extension, ".act") == 0 || _stricmp(extension, ".str") == 0);
entry.flags |= special ? 4 : 2;
maximum = std::max(maximum, entry.alignedSize);
sequence += 5;
legacyKey -= 2;
}
SortEntries(this->m_entries);
this->m_scratch.resize(maximum);
return true;
}
// OFFSET: 0x00AEC420
// FUNCTION: fn_18134
bool CGPak::ReadTableV2() {
const std::uint8_t* prefix = this->m_file->Read(this->m_tableOffset, 8);
std::uint32_t compressed = Read32(prefix);
std::uint32_t original = Read32(prefix + 4);
this->m_tableSize = compressed + 8;
const std::uint8_t* source = this->m_file->Read(this->m_tableOffset + 8, compressed);
uLongf length = original + 8;
std::vector<std::uint8_t> decoded(length);
if (uncompress(decoded.data(), &length, source, compressed) != Z_OK) {
return false;
}
InitializeEntries(this->m_entries, this->m_entryCount);
const std::uint8_t* cursor = decoded.data();
std::uint32_t maximum = 0;
for (myGPack::PakEntry& entry : this->m_entries) {
const char* name = reinterpret_cast<const char*>(cursor);
const std::uint8_t* metadata = cursor + std::strlen(name) + 1;
cursor = metadata + 17;
entry.compressedSize = Read32(metadata);
entry.alignedSize = Read32(metadata + 4);
entry.originalSize = Read32(metadata + 8);
entry.flags = metadata[12];
entry.dataOffset = Read32(metadata + 13);
entry.name.Assign(name);
maximum = std::max(maximum, entry.alignedSize);
}
SortEntries(this->m_entries);
this->m_scratch.resize(maximum);
return true;
}
// OFFSET: 0x00AEC620
// FUNCTION: fn_18135
bool CGPak::ReadTableV3() {
const std::uint8_t* prefix = this->m_file->Read(this->m_tableOffset, 12);
std::uint32_t extra = Read32(prefix);
std::uint32_t compressed = Read32(prefix + 4);
std::uint32_t original = Read32(prefix + 8);
this->m_tableSize = extra + compressed + 12;
const std::uint8_t* source = this->m_file->Read(this->m_tableOffset + 12, compressed);
uLongf length = original + 8;
std::vector<std::uint8_t> decoded(length);
if (uncompress(decoded.data(), &length, source, compressed) != Z_OK) {
return false;
}
InitializeEntries(this->m_entries, this->m_entryCount);
const std::uint8_t* cursor = decoded.data();
std::uint32_t maximum = 0;
for (myGPack::PakEntry& entry : this->m_entries) {
const char* name = reinterpret_cast<const char*>(cursor);
const std::uint8_t* metadata = cursor + std::strlen(name) + 1;
cursor = metadata + 21;
entry.compressedSize = Read32(metadata);
entry.alignedSize = Read32(metadata + 4);
entry.originalSize = Read32(metadata + 8);
entry.flags = metadata[12];
entry.dataOffset = Read64(metadata + 13);
entry.name.Assign(name);
maximum = std::max(maximum, entry.alignedSize);
}
SortEntries(this->m_entries);
this->m_scratch.resize(maximum);
return true;
}
// OFFSET: 0x00AEBA30
// FUNCTION: fn_18128
bool CGPak::Find(const myGPack::PakName& name, myGPack::PakEntry* entry) const {
auto found = std::lower_bound(
this->m_entries.begin(), this->m_entries.end(), name,
[](const myGPack::PakEntry& candidate, const myGPack::PakName& key) { return candidate.name < key; }
);
if (found == this->m_entries.end() || found->name != name) {
return false;
}
if (entry) {
*entry = *found;
}
return true;
}
// OFFSET: 0x00AEBAE0
// FUNCTION: fn_18129
void CGPak::ReadAuxiliary(std::vector<std::uint8_t>& output, std::uint64_t* identifier) {
if (identifier) {
*identifier = UINT64_MAX;
}
output.clear();
std::uint32_t size;
std::uint64_t offset;
switch (this->m_version & 0xFF00) {
case 0x200:
if (this->m_version < 0x201) {
return;
}
size = Read32(this->m_file->Read(this->m_tableOffset - 4, 4));
offset = this->m_tableOffset - size - 4;
break;
case 0x300: {
const std::uint8_t* prefix = this->m_file->Read(this->m_tableOffset, 12);
size = Read32(prefix);
offset = this->m_tableOffset + Read32(prefix + 4) + 12;
break;
}
default:
return;
}
if (!size) {
return;
}
const std::uint8_t* data = this->m_file->Read(offset, size);
output.resize(size);
std::memcpy(output.data(), data, size);
if (identifier) {
*identifier = ReadAuxiliaryIdentifier(output.data(), output.size());
}
}
Reference in a new issue View git blame Copy permalink