502 lines
16 KiB
C++
502 lines
16 KiB
C++
// LegoBlobReader.cpp : This file contains the 'main' function. Program execution begins and ends there.
|
|
//
|
|
|
|
#include <conio.h>
|
|
#include <stdio.h>
|
|
#include <malloc.h>
|
|
#include <math.h>
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
typedef unsigned char byte;
|
|
typedef unsigned short uint16;
|
|
typedef unsigned int uint32;
|
|
typedef __int64 int64;
|
|
|
|
static char const* FILE_NAME = "GAMEPROGRESS.BLOB";
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
static void FlipBytes(void* data, size_t buffer_len)
|
|
{
|
|
byte* buffer = (byte*)data;
|
|
size_t flip_count = buffer_len >> 1;
|
|
for (size_t i = 0; i < flip_count; ++i) {
|
|
std::swap(buffer[i], buffer[buffer_len - i - 1]);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
struct type_info_t
|
|
{
|
|
std::string name;
|
|
size_t byte_size;
|
|
|
|
inline bool is_valid() const { return byte_size > 0; }
|
|
};
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
struct class_member_info_t
|
|
{
|
|
std::string name;
|
|
type_info_t const* type;
|
|
};
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
struct class_info_t
|
|
{
|
|
std::string name;
|
|
|
|
std::vector<class_member_info_t> members;
|
|
};
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
// Globals
|
|
//--------------------------------------------------------------------------------------------------------
|
|
|
|
std::vector<type_info_t> Types;
|
|
std::vector<class_info_t> Classes;
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
//--------------------------------------------------------------------------------------------------------
|
|
class BinaryReader
|
|
{
|
|
public:
|
|
BinaryReader(char const* filename);
|
|
~BinaryReader();
|
|
|
|
bool is_valid() const { return (nullptr != m_buffer); }
|
|
bool is_finished() const { return m_offset >= m_byte_size; }
|
|
|
|
public: // accessors
|
|
size_t get_byte_size() const { return m_byte_size; }
|
|
size_t get_read_offset() const { return m_offset; }
|
|
size_t get_bytes_remaining() const { return get_byte_size() - get_read_offset(); }
|
|
|
|
byte* get_read_head() const { return m_buffer + m_offset; }
|
|
|
|
void set_read_offset(size_t offset) { m_offset = offset; }
|
|
|
|
public: // functions
|
|
bool skip(size_t num_bytes);
|
|
bool read_bytes(void* dst, size_t num_bytes);
|
|
|
|
std::string read_string();
|
|
|
|
template <typename T>
|
|
T read(T const& def_value)
|
|
{
|
|
T val;
|
|
if (read_bytes(&val, sizeof(T))) {
|
|
// FlipBytes(&val, sizeof(T));
|
|
return val;
|
|
} else {
|
|
return def_value;
|
|
}
|
|
}
|
|
|
|
bool read_type_info(type_info_t* out);
|
|
|
|
|
|
public: // operators
|
|
byte operator[](size_t offset) const { return m_buffer[offset]; }
|
|
|
|
public:
|
|
byte* m_buffer = nullptr;
|
|
size_t m_byte_size = 0;
|
|
size_t m_offset = 0;
|
|
};
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
// BinearyReader implementation
|
|
//--------------------------------------------------------------------------------------------------------
|
|
//--------------------------------------------------------------------------------------------------------
|
|
BinaryReader::BinaryReader(char const* filename)
|
|
{
|
|
FILE* fp = nullptr;
|
|
::fopen_s(&fp, filename, "rb");
|
|
if (nullptr == fp) {
|
|
return;
|
|
}
|
|
|
|
::fseek(fp, 0, SEEK_END);
|
|
size_t eof = ::ftell(fp);
|
|
::fseek(fp, 0, SEEK_SET);
|
|
|
|
m_buffer = (byte*) ::malloc(eof);
|
|
if (nullptr != m_buffer) {
|
|
m_byte_size = ::fread(m_buffer, 1, eof, fp);
|
|
}
|
|
|
|
::fclose(fp);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
BinaryReader::~BinaryReader()
|
|
{
|
|
if (nullptr != m_buffer) {
|
|
delete m_buffer;
|
|
m_buffer = nullptr;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
bool BinaryReader::skip(size_t num_bytes)
|
|
{
|
|
if (get_bytes_remaining() < num_bytes) {
|
|
return false;
|
|
}
|
|
|
|
m_offset += num_bytes;
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
bool BinaryReader::read_bytes(void* dst, size_t num_bytes)
|
|
{
|
|
byte* src = get_read_head();
|
|
if (!skip(num_bytes)) {
|
|
return false;
|
|
}
|
|
|
|
::memcpy(dst, src, num_bytes);
|
|
return true;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
std::string BinaryReader::read_string()
|
|
{
|
|
uint32 len = read<uint32>(0);
|
|
std::string str;
|
|
|
|
if (len > 0) {
|
|
str.resize(len + 1);
|
|
read_bytes(&str[0], len);
|
|
str[len] = 0;
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
bool BinaryReader::read_type_info(type_info_t* out)
|
|
{
|
|
read<uint32>(0); // offset to next
|
|
read_string(); // "type"
|
|
|
|
out->name = read_string();
|
|
out->byte_size = read<uint32>(0);
|
|
|
|
return out->is_valid();
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
// termination function for file reading - just prints where we left off
|
|
//--------------------------------------------------------------------------------------------------------
|
|
static void DisplayProgress(BinaryReader const& reader)
|
|
{
|
|
size_t bytes_to_show = reader.get_bytes_remaining();
|
|
bytes_to_show = std::min<size_t>(bytes_to_show, 16);
|
|
size_t offset = reader.get_read_offset();
|
|
printf("\n\n--== PROGRESS ==--\nAt %u (0x%08x) into buffer... Next %u byte(s) are...\n> ", offset, offset, bytes_to_show);
|
|
for (size_t i = 0; i < bytes_to_show; ++i) {
|
|
byte b = reader[offset + i];
|
|
printf("%02X ", b);
|
|
}
|
|
printf("<\n\n");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
//--------------------------------------------------------------------------------------------------------
|
|
static void ParseTypes(BinaryReader& reader)
|
|
{
|
|
uint32 type_block_size = reader.read<uint32>(0); // 0x02f4
|
|
std::string typelist = reader.read_string();
|
|
uint32 type_count = reader.read<uint32>(0); // 0x1A?std::vector<type_info_t> types;
|
|
printf("\n======\nType List (%u total types)...\n", type_count);
|
|
|
|
|
|
for (uint32 i = 0; i < type_count; ++i) {
|
|
type_info_t type;
|
|
reader.read_type_info(&type);
|
|
|
|
// push even bad types in to keep the index
|
|
Types.push_back(type);
|
|
if (type.is_valid()) {
|
|
printf("> Type [%02u]: %s (%u B)\n", i, type.name.c_str(), type.byte_size);
|
|
}
|
|
else {
|
|
printf("> Type [%02u]: REDACTED\n", i);
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
//--------------------------------------------------------------------------------------------------------
|
|
static void ParseClasses(BinaryReader& reader)
|
|
{
|
|
uint32 class_block_size = reader.read<uint32>(0);
|
|
uint32 end_of_class = reader.get_read_offset() + class_block_size - sizeof(uint32);
|
|
std::string classlist = reader.read_string();
|
|
uint32 class_count = reader.read<uint32>(0);
|
|
|
|
printf("\n======\nClass List (%u total classes)...\n", class_count);
|
|
for (uint32 i = 0; i < class_count; ++i) {
|
|
class_info_t class_info;
|
|
|
|
uint32 class_size = reader.read<uint32>(0); // to skip to end of this class
|
|
std::string class_id = reader.read_string(); // "Class"
|
|
class_info.name = reader.read_string();
|
|
printf("\n> [%u] class: %s\n:", i, class_info.name.c_str());
|
|
|
|
uint32 some_count = reader.read<uint32>(0);
|
|
std::string ver_str = reader.read_string(); // "Version"
|
|
uint32 ver_num_maybe = reader.read<uint32>(0);
|
|
uint32 offset_maybe = reader.read<uint32>(0);
|
|
|
|
std::string types_str = reader.read_string(); // "Types"
|
|
|
|
reader.skip(1); // 0
|
|
uint32 mem_count = reader.read<uint32>(0); // 0x07 ?
|
|
printf(">> member count: %u\n", mem_count);
|
|
|
|
for (uint32 mi = 0; mi < mem_count; ++mi) {
|
|
uint32 type_idx = reader.read<uint32>(0); // 0x02 ?
|
|
type_info_t const& type = Types[type_idx];
|
|
|
|
std::string mem_name = reader.read_string();
|
|
printf(" %s : %s;\n", mem_name.c_str(), type.name.c_str());
|
|
|
|
class_member_info_t mem_info;
|
|
mem_info.name = mem_name;
|
|
mem_info.type = &type;
|
|
class_info.members.push_back(mem_info);
|
|
|
|
// uint16 skip_to_next = reader.read<uint16>(0);
|
|
|
|
/*
|
|
uint32 type_size = type.byte_size;
|
|
if (type_size != ~0U) {
|
|
reader.skip(type_size); // def value - based on type
|
|
}
|
|
*/
|
|
|
|
/*
|
|
uint32 const STOP_VALUE = 0x80'00'00'00;
|
|
uint32 val = reader.read<uint32>(STOP_VALUE);
|
|
while (val != STOP_VALUE) {
|
|
val = reader.read<uint32>(STOP_VALUE);
|
|
}
|
|
*/
|
|
|
|
uint32 v0 = reader.read<uint32>(0);
|
|
uint32 v1 = reader.read<uint32>(0);
|
|
uint32 v2 = reader.read<uint32>(0);
|
|
uint32 v3 = reader.read<uint32>(0);
|
|
uint32 v4 = reader.read<uint32>(0);
|
|
|
|
printf(" %08X %08X %08X %08X %08X (%s)\n", v0, v1, v2, v3, v4, type.name.c_str());
|
|
|
|
Classes.push_back(class_info);
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
//--------------------------------------------------------------------------------------------------------
|
|
static void ParseOLST(BinaryReader& reader, size_t end_of_section)
|
|
{
|
|
reader.read<uint32>(0); // 1 - subobject count?
|
|
|
|
reader.read<uint16>(0); // skip two bytes, why? type? (0)
|
|
reader.read<uint32>(0); // sub section len? 0x098c (probably how much room is left)
|
|
|
|
std::string subobj_name = reader.read_string(); // MOBJ - map object?
|
|
reader.read<uint32>(0); // 0
|
|
reader.read<uint32>(0); // 9 - number of episode sections to read.
|
|
|
|
//------
|
|
|
|
// cut1
|
|
std::string path0 = reader.read_string(); // cut/story/ep1/ep1_main/ep1_mainintro_sequence.scene_baked
|
|
reader.read_string(); // ""
|
|
reader.read_string(); // ""
|
|
reader.read_string(); // ""
|
|
|
|
// level1
|
|
std::string path1 = reader.read_string(); //levels/hub/prelevels/episode_01/ep1_prelevel_01/ep1pl01_catchupcrawl.scene_baked
|
|
reader.read_string(); // ""
|
|
reader.read<uint32>(0); // 0
|
|
reader.read<uint32>(0); // 0
|
|
|
|
reader.read<byte>(0); // 1
|
|
reader.read_string(); // ""
|
|
reader.read_string(); // ""
|
|
|
|
reader.read<uint16>(0); //0
|
|
reader.read_string();
|
|
|
|
// ep1
|
|
std::string ep01 = reader.read_string(); // Episode1
|
|
reader.read<uint16>(0); // 0
|
|
|
|
//------
|
|
|
|
// cut
|
|
std::string cut2 = reader.read_string(); // cut/story/ep2/ep2_main/ep2_mainintro_sequence.scene_baked
|
|
reader.read_string(); // ""
|
|
reader.read_string(); // ""
|
|
reader.read_string(); // ""
|
|
|
|
// level
|
|
std::string level2 = reader.read_string(); // levels/hub/prelevels/episode_02/ep2_prelevel_01/ep2pl01_catchupcrawl.scene_baked
|
|
reader.read_string(); // ""
|
|
reader.read<uint32>(0); // 0
|
|
reader.read<uint32>(0); // 0
|
|
|
|
reader.read<byte>(0); // 1
|
|
reader.read_string(); // ""
|
|
reader.read_string(); // ""
|
|
|
|
reader.read<uint16>(0); //0
|
|
reader.read_string();
|
|
|
|
// ep
|
|
std::string ep2 = reader.read_string(); // Episode2
|
|
reader.read<uint16>(0); // 0
|
|
|
|
//------
|
|
|
|
// cut
|
|
std::string cut3 = reader.read_string(); // cut/story/ep3/ep3_main/ep3_mainintro_sequence.scene_baked
|
|
reader.read_string(); // ""
|
|
reader.read_string(); // ""
|
|
reader.read_string(); // ""
|
|
|
|
// level
|
|
std::string level3 = reader.read_string(); // levels/hub/prelevels/episode_03/ep3_prelevel_01/ep3pl01_catchupcrawl.scene_baked
|
|
|
|
reader.read_string(); // ""
|
|
reader.read<uint32>(0); // 0
|
|
reader.read<uint32>(0); // 0
|
|
|
|
reader.read<byte>(0); // 1
|
|
reader.read_string(); // ""
|
|
reader.read_string(); // ""
|
|
|
|
reader.read<uint16>(0); //0
|
|
reader.read_string();
|
|
|
|
|
|
// ep
|
|
std::string ep3 = reader.read_string(); // Episode3
|
|
reader.read<uint16>(0); // 0
|
|
|
|
//------
|
|
|
|
// cut
|
|
std::string hub1 = reader.read_string(); // Levels/Hub/Planets/Tatooine/Locations/Settlements/Tatooine_desertArea/tatooine_desertarea.scene_baked
|
|
std::string arrive1 = reader.read_string(); // ArrivalPointFrom4_1
|
|
std::string hub2 = reader.read_string(); // Levels/Hub/Planets/Tatooine/Locations/Settlements/Tatooine_desertArea/tatooine_desertarea.scene_baked
|
|
std::string arrive2 = reader.read_string(); // ArrivalPointFrom4_1
|
|
|
|
// level
|
|
std::string hub3 = reader.read_string(); // levels/hub/prelevels/episode_04/ep4_prelevel_02/e04pl02_catchupcrawl.scene_baked
|
|
reader.read_string(); // ""
|
|
|
|
// two names?
|
|
reader.read<uint32>(0); // 2
|
|
reader.read_string(); // "BB8"
|
|
reader.read_string(); // "Greedo"
|
|
|
|
reader.read<uint32>(0); // 2
|
|
reader.read_string(); // "FirstOrder_SFTIEFighter"
|
|
reader.read_string(); // "Naboo_Yacht"
|
|
|
|
reader.read<byte>(0); // false
|
|
reader.read_string(); // "Prelevels"
|
|
reader.read_string(); // "Ep4Pre2"
|
|
|
|
reader.read<uint16>(0); // 1
|
|
reader.read_string(); // "HYPERSPACE_LOCKED"
|
|
std::string test = reader.read_string(); // "Episode4"
|
|
reader.read<uint16>(0); // 1
|
|
|
|
DisplayProgress(reader); //
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
// main file reading function
|
|
//--------------------------------------------------------------------------------------------------------
|
|
static void ParseBuffer(BinaryReader& reader)
|
|
{
|
|
uint32 version = reader.read<uint32>(0);
|
|
printf("Version: %u\n", version);
|
|
|
|
std::string streaminfo = reader.read_string();
|
|
printf("Label: %s\n", streaminfo.c_str());
|
|
|
|
uint32 unknown0 = reader.read<uint32>(0); // 0x33
|
|
uint32 unknown1 = reader.read<uint32>(0); // 0x01
|
|
uint32 unknown2 = reader.read<uint32>(0); // 0x00
|
|
|
|
ParseTypes(reader);
|
|
ParseClasses(reader);
|
|
|
|
// print the sections
|
|
printf("\n\n\n----------------------------\nReading Sections\n----------------------------\n");
|
|
size_t num_sections = reader.read<uint32>(0);
|
|
size_t sections_read = 0;
|
|
while (!reader.is_finished())
|
|
{
|
|
uint32 section_len = reader.read<uint32>(0);
|
|
if (section_len == 0) {
|
|
break;
|
|
}
|
|
|
|
uint32 end_of_section = reader.get_read_offset() - sizeof(uint32) + section_len;
|
|
std::string section_name = reader.read_string(); // "OLST"
|
|
++sections_read;
|
|
|
|
printf("Section '%s' at 0x%08x.\n", section_name.c_str(), end_of_section - section_len);
|
|
if (_strcmpi(section_name.c_str(), "OLST") == 0) {
|
|
ParseOLST(reader, end_of_section);
|
|
}
|
|
|
|
reader.set_read_offset(end_of_section); // this is taking me past the end by 4;
|
|
}
|
|
printf("\nRead %u out of %u sections.", sections_read, num_sections);
|
|
|
|
printf("\n\n");
|
|
DisplayProgress(reader);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------------
|
|
// main
|
|
//--------------------------------------------------------------------------------------------------------
|
|
int main()
|
|
{
|
|
BinaryReader reader(FILE_NAME);
|
|
if (reader.is_valid()) {
|
|
ParseBuffer(reader);
|
|
}
|
|
|
|
printf("\n\n\nPress Any Key...\n");
|
|
_getch();
|
|
}
|
|
|
|
// Run program: Ctrl + F5 or Debug > Start Without Debugging menu
|
|
// Debug program: F5 or Debug > Start Debugging menu
|
|
|
|
// Tips for Getting Started:
|
|
// 1. Use the Solution Explorer window to add/manage files
|
|
// 2. Use the Team Explorer window to connect to source control
|
|
// 3. Use the Output window to see build output and other messages
|
|
// 4. Use the Error List window to view errors
|
|
// 5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
|
|
// 6. In the future, to open this project again, go to File > Open > Project and select the .sln file
|