XeNTaX

Code: Select all

struct PACK_Header
{
    DWORD Magic; // 'PACK'
    DWORD Version; // 4 in Nier
    DWORD PackSize;
    DWORD UnkData_Offset; // Offset to some unknown/encrypted data, sometimes looks like floats - offset from base of header

    DWORD Unk10; // value seems to scale with PackSize

    DWORD NameCount;
    DWORD NameTableOffset;

    DWORD Table1_FileCount;
    DWORD Table1_Offset;

    DWORD Table2_FileCount;
    DWORD Table2_Offset;
};

typedef struct 
{
    local long pos = FTell();

    DWORD NameHash;
    DWORD NameOffset;
    DWORD Unk8;

    local long endPos = FTell();

    FSeek(pos + 0x4 + NameOffset); // 0x4 = offset of NameOffset field
    string FileName;
    FSeek(endPos);
} PACK_NameEntry<read=ReadPACK_NameEntry>;

typedef struct
{
    local long pos = FTell();

    DWORD NameHash;
    DWORD NameOffset;
    DWORD DataLength;
    DWORD DataOffset;
    DWORD ErrorOffset; // offset to some weird error string, maybe is set to something besides error on some files...

    local long endPos = FTell();

    FSeek(pos + 0x4 + NameOffset); // 0x4 = offset of NameOffset field
    string FileName;

    FSeek(pos + 0xC + DataOffset);
    BYTE Data[DataLength] <optimize=false>;

    // ErrorOffset is sometimes set to 0x80XXXXXX, no idea what purpose of it is yet
    if(ErrorOffset < 0x80000000) {
        FSeek(pos + 0x10 + ErrorOffset);
        BYTE StringLength;
        char String[StringLength] <optimize=false>;
    }

    FSeek(endPos);
} PACK_FileEntry<read=ReadPACK_FileEntry>;

// funcs to let template window show names next to entry
string ReadPACK_NameEntry(PACK_NameEntry& entry)
{
    return entry.FileName;
}

string ReadPACK_FileEntry(PACK_FileEntry& entry)
{
    return entry.FileName;
}

// Seperate struct so files can be collapsed in template window
struct PACK_NameTable(int NameCount)
{
    PACK_NameEntry Entries[NameCount] <optimize=false>;
};

struct PACK_FileTable(int FileCount)
{
    PACK_FileEntry Entries[FileCount] <optimize=false>;
};

PACK_Header Header;

FSeek(Header.NameTableOffset + 0x18); // 0x18 = offset of NameTableOffset field
if(Header.NameCount > 0)
    PACK_NameTable Names(Header.NameCount);

// Table1/Table2 seem to share same struct
FSeek(Header.Table1_Offset + 0x20);
if (Header.Table1_FileCount > 0)
    PACK_FileTable Table1(Header.Table1_FileCount);

FSeek(Header.Table2_Offset + 0x28);
if (Header.Table2_FileCount > 0)
    PACK_FileTable Table2(Header.Table2_FileCount);

Code: Select all

struct BXON_Header
{
    local long header_pos = FTell();

    DWORD Magic;
    DWORD Version; // 3 in Nier, 1 in DQXIS

    DWORD StructNameHash;
    DWORD StructNameOffset;
    DWORD StructDataOffset;

    FSeek(header_pos + 0xC + StructNameOffset);
    string StructName;
};

enum<BYTE> CompressionType
{
    Solid = 0,
    SeperateBlobs1 = 1,
    SeperateBlobs2 = 2, // dunno what difference is
};

typedef struct
{
    local long archive_pos = FTell();

    DWORD NameOffset;
    DWORD Unk4; // always 4?
    CompressionType Flags;

    // pad bytes always set to 0x40?
    BYTE Pad9;
    BYTE PadA;
    BYTE PadB;

    local long archive_end_pos = FTell();

    FSeek(archive_pos + 0 + NameOffset);
    string Name;

    FSeek(archive_end_pos);
} BXON_tpArchiveFileParam_Archive<read=ReadBXON_tpArchiveFileParam_Archive>;

typedef struct
{
    local long file_pos = FTell();

    DWORD Unk0;
    DWORD NameOffset;
    DWORD FileOffset<read=ReadFileOffset>; // offset needs to be multiplied by 0x10 always!

    DWORD CompressedLength;
    DWORD UncompressedHeadersLength; // size of PACK headers/data
    DWORD UncompressedDataLength; // seems to be the size of UnkData part of PACK?

    BYTE ArchiveIdx;
    BYTE Flags;

    // pad bytes always set to 0x40?
    BYTE Pad1A;
    BYTE Pad1B;

    local long file_end_pos = FTell();

    FSeek(file_pos + 0x4 + NameOffset);
    string Name;

    FSeek(file_end_pos);
} BXON_tpArchiveFileParam_File<read=ReadBXON_tpArchiveFileParam_File>;

// multiplies offset by 0x10 for template window view
string ReadFileOffset(DWORD offset)
{
    local uint64 offs = offset;
    offs = offs * 0x10;
    string s;
    SPrintf(s, "%Lu", offs);
    return s;
}

string ReadBXON_tpArchiveFileParam_Archive(BXON_tpArchiveFileParam_Archive& entry)
{
    return entry.Name;
}

string ReadBXON_tpArchiveFileParam_File(BXON_tpArchiveFileParam_File& entry)
{
    string s;
    SPrintf(s, "%s:/%s", Archive.Archives[entry.ArchiveIdx].Name, entry.Name);
    return s;
}

// Seperate struct so files can be collapsed in template window...
struct BXON_tpArchiveFileParam_FileTable(int FileCount)
{
    BXON_tpArchiveFileParam_File Files[FileCount] <optimize=false>;
};

struct BXON_tpArchiveFileParam
{
    local long archive_param_pos = FTell();

    DWORD ArchiveCount;
    DWORD ArchiveTableOffset;
    DWORD FileCount;
    DWORD FileTableOffset;

    FSeek(archive_param_pos + 0x4 + ArchiveTableOffset);
    BXON_tpArchiveFileParam_Archive Archives[ArchiveCount] <optimize=false>;

    FSeek(archive_param_pos + 0xC + FileTableOffset);
    BXON_tpArchiveFileParam_FileTable Files(FileCount);
};

local long pos = FTell();

BXON_Header Header;

if(Header.StructName == "tpArchiveFileParam")
{
    FSeek(pos + 0x10 + Header.StructDataOffset);
    BXON_tpArchiveFileParam Archive;
}