Table project - they fixed the bug.

LegoBlobReader/LegoBlobReader.cpp

@@ -14,7 +14,8 @@ typedef unsigned short uint16;
 typedef unsigned int uint32; 
 typedef __int64 int64; 
 
-static char const* FILE_NAME = "GAMEPROGRESS.broke.blob"; 
+static char const* FILE_NAME = "GAMEPROGRESS.BLOB"; 
+
 
 
 //--------------------------------------------------------------------------------------------------------
@@ -36,6 +37,28 @@ struct type_info_t
     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
@@ -45,6 +68,7 @@ class BinaryReader
         ~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; }
@@ -53,6 +77,8 @@ class BinaryReader
 
         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); 
@@ -167,6 +193,7 @@ bool BinaryReader::read_type_info(type_info_t* out)
 }
 
 
+
 //--------------------------------------------------------------------------------------------------------
 // termination function for file reading - just prints where we left off
 //--------------------------------------------------------------------------------------------------------
@@ -175,12 +202,231 @@ 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("\nAt %u (0x%08x) into buffer...  Next %u byte(s) are...\n> ", offset, offset, bytes_to_show); 
+    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"); 
+    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); // 
 }
 
 //--------------------------------------------------------------------------------------------------------
@@ -198,75 +444,34 @@ static void ParseBuffer(BinaryReader& reader)
     uint32 unknown1 = reader.read<uint32>(0); // 0x01
     uint32 unknown2 = reader.read<uint32>(0); // 0x00
     
-    // reading a type infos
-    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("\nType List (%u total types)...\n", type_count);
+    ParseTypes(reader); 
+    ParseClasses(reader); 
 
-    std::vector<type_info_t> types; 
-    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); 
+    // 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; 
         }
-    }
 
-    // read class infos
-    uint32 class_block_size = reader.read<uint32>(0); 
-    std::string classlist = reader.read_string(); 
-    uint32 class_count = reader.read<uint32>(0); 
+        uint32 end_of_section = reader.get_read_offset() - sizeof(uint32) + section_len; 
+        std::string section_name = reader.read_string();  // "OLST"
+        ++sections_read; 
 
-    printf("\nClass List (%u total classes)...\n", class_count); 
-    for (uint32 i = 0; i < class_count; ++i) {
-        uint32 class_size = reader.read<uint32>(0); // to skip to end of this class
-        std::string class_id = reader.read_string(); // "Class"
-        std::string class_name = reader.read_string();
-        printf("> Class: %s\n:", class_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[mi];
-
-            std::string mem_name = reader.read_string(); 
-            printf(">> %s : %s;\n", mem_name.c_str(), type.name.c_str()); 
-
-            // 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); 
-            }
-            reader.skip(8); // usually (0, 0), or (0, -1)
+        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); 
 }