arkparse 0.5.2__tar.gz → 0.5.3__tar.gz

{arkparse-0.5.2 → arkparse-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparse
-Version: 0.5.2
+Version: 0.5.3
 Summary: A package to parse and modify ark save files
 Project-URL: Homepage, https://github.com/VincentHenauGithub/ark-save-parser
 Author-email: Vincent Henau <vincent.henau.github@gmail.com>

{arkparse-0.5.2 → arkparse-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arkparse"
-version = "0.5.2"
+version = "0.5.3"
 dependencies = [
     "rcon>=2.4.9",
     "numpy>=2.3.2",

{arkparse-0.5.2 → arkparse-0.5.3}/src/arkparse/api/json_api.py

@@ -455,7 +455,12 @@ class JsonApi:
                 try:
                     obj_uuid = SaveConnection.byte_array_to_uuid(row[0])
                     byte_buffer = ArkBinaryParser(row[1], self.save.save_context)
-                    class_name = byte_buffer.read_name()
+                    # Use the string-name-aware reader: some objects store their
+                    # class as an inline string instead of a name-table id, which
+                    # a raw read_name() can't resolve (raises when generate_unknown
+                    # is off). Those are never items, so they fall through the
+                    # filter below.
+                    class_name, *_ = ArkGameObject.read_name(obj_uuid, byte_buffer)
 
                     if "/PrimalItemArmor_" not in class_name and \
                             "/PrimalItem_" not in class_name and \

{arkparse-0.5.2 → arkparse-0.5.3}/src/arkparse/object_model/ark_game_object.py

@@ -45,6 +45,8 @@ class ArkGameObject(ArkPropertyContainer):
         self.uuid = uuid
         self.blueprint = blueprint
         string_name = False
+        string_names: List[str] = []
+        string_name_offsets: List[int] = []
         super().__init__()
         if binary_reader:
             ArkSaveLogger.set_file(binary_reader, "debug.bin")
@@ -55,7 +57,7 @@ class ArkGameObject(ArkPropertyContainer):
                     self.uuid2: UUID = None
                     binary_reader.set_position(0)
 
-                    self.blueprint, string_name = ArkGameObject.read_name(uuid, binary_reader)
+                    self.blueprint, string_name, string_names, string_name_offsets = ArkGameObject.read_name(uuid, binary_reader)
                     ArkSaveLogger.parser_log(f"Read Blueprint: {self.blueprint} (String name: {string_name})")
 
                     sContext : SaveContext = binary_reader.save_context
@@ -69,6 +71,14 @@ class ArkGameObject(ArkPropertyContainer):
                 binary_reader.validate_uint32(0)
                 if string_name:
                     binary_reader.read_uint16()
+                    # Names embedded in a string-name header are stored as
+                    # strings (never as name-table refs), mirroring what the
+                    # regular names block below would produce.
+                    self.names = string_names
+                    self.name_metadata = [
+                        _NameMetadata(name, offset, True)
+                        for name, offset in zip(string_names, string_name_offsets)
+                    ]
 
             try:
                 if not (no_header or string_name):
@@ -250,6 +260,8 @@ class ArkGameObject(ArkPropertyContainer):
     def read_name(obj_uuid: UUID, reader: ArkBinaryParser) -> str:
         reader.set_position(0)
         string_name = False
+        extra_names: List[str] = []
+        extra_offsets: List[int] = []
 
         try:
             class_name = reader.read_name()
@@ -260,18 +272,26 @@ class ArkGameObject(ArkPropertyContainer):
             try:
                 unknow_id = reader.read_uint32()
                 reader.validate_uint64(0)
-                reader.read_int()
+                name_count = reader.read_int()
                 class_name = reader.read_string()
                 # reader.validate_uint32(0)
                 string_name = True
+                # The string-name header carries a name count: the first string is
+                # the class, any further strings are the object's names (e.g. the
+                # instance name of a DeathItemCache) that the name-table format
+                # would store separately. Consume them so the trailing padding
+                # lines up (otherwise validate_uint32(0) hits the next length).
+                for _ in range(max(0, name_count - 1)):
+                    extra_offsets.append(reader.position + 4)
+                    extra_names.append(reader.read_string())
                 ArkSaveLogger.parser_log(f"Object {obj_uuid} has string class name {class_name} instead of name table reference")
             except Exception as e:
                 ArkSaveLogger.error_log(f"Error reading class name for object {obj_uuid}: {e}")
                 reader.structured_print(to_default_file=True)
                 # input("Press Enter to continue...")
                 class_name = "UnknownClass"
-                
-        return class_name, string_name
+
+        return class_name, string_name, extra_names, extra_offsets
     
     def get_short_name(self) -> str:
         to_strip_end = [

{arkparse-0.5.2 → arkparse-0.5.3}/src/arkparse/parsing/ark_property.py

@@ -397,6 +397,16 @@ class ArkProperty:
     
         return prop
 
+    @staticmethod
+    def _has_struct_reader(struct_type: str) -> bool:
+        """Whether this struct type has a dedicated (fixed-layout) reader.
+
+        Types without one are read generically as a property list; see
+        ``_read_struct_body`` and the guarded array backup in
+        ``read_array_property``.
+        """
+        return ArkStructType.from_type_name(struct_type) in _STRUCT_READERS
+
     @staticmethod
     def read_array_property(key: str, type_: str, position: int, bb: "ArkBinaryParser", data_size: int) -> Tuple["ArkProperty", int]:
         # V14 no position in array
@@ -428,31 +438,51 @@ class ArkProperty:
                 bb.set_position(bb.position - 4)
 
             array_items = bb.read_uint32()
+            array_end = data_start_position + data_size
 
-            # if array_content_type == "PrimalCharacterStatusValueModifier":
-            #     ArkSaveLogger.set_log_level(ArkSaveLogger.LogTypes.PARSER, True)
+            # Structs without a dedicated reader are read generically as a property
+            # list (see _read_struct_body). That backup is reliable for well-formed,
+            # None-terminated property-list structs but can't be guaranteed for an
+            # arbitrary packed layout, so guard it: if a generic element read raises,
+            # recover by skipping to the array's known end and record the type for
+            # follow-up rather than failing the whole object. A dedicated reader
+            # raising is a real bug, so let that propagate.
+            has_reader = ArkProperty._has_struct_reader(array_content_type)
 
             with log_block(f"Arr({array_content_type})"):
                 ArkSaveLogger.parser_log(
                     f"[STRUCT ARRAY: key='none'; nr_of_value={array_items}; type={array_content_type}; bin_length={data_size}]"
                 )
-                struct_array = [
-                    ArkProperty.read_struct_property(bb, data_size, array_content_type, True)[0]
-                    for _ in range(array_items)
-                ]
+                struct_array = []
+                try:
+                    for _ in range(array_items):
+                        struct_array.append(
+                            ArkProperty.read_struct_property(bb, data_size, array_content_type, True)[0]
+                        )
+                except Exception as exc:
+                    if has_reader:
+                        raise
+                    ArkSaveLogger.warning_log(
+                        f"Generic read of struct array '{array_content_type}' failed after "
+                        f"{len(struct_array)}/{array_items} element(s): {exc}; skipping to end of array"
+                    )
+                    ArkSaveLogger._notify_struct_mismatch(
+                        array_content_type, data_size, data_start_position, bb.position, bb
+                    )
+                    bb.set_position(array_end)
 
             prop = ArkProperty(key, type_, position, 0, struct_array)
-            if bb.position != data_start_position + data_size:
+            if bb.position != array_end:
+                # The read didn't consume exactly the declared size. Record the
+                # mismatch (the testbench captures these) and realign to the end.
                 ArkSaveLogger.warning_log(
-                    f"Array read incorrectly, bytes left to read: {data_start_position + data_size - bb.position}, current position: {bb.position}"
+                    f"Array of struct '{array_content_type}' read incorrectly, "
+                    f"bytes off: {array_end - bb.position}; realigning to end of array"
                 )
-                ArkSaveLogger.warning_log(f"Skipping to the end of the struct, type: {array_content_type}")
-                bb.set_position(data_start_position + data_size)
-                bb.structured_print(to_default_file=True)
-                ArkSaveLogger.open_hex_view(True)
-
-            # if array_content_type == "PrimalCharacterStatusValueModifier":
-            #     ArkSaveLogger.set_log_level(ArkSaveLogger.LogTypes.PARSER, False)
+                ArkSaveLogger._notify_struct_mismatch(
+                    array_content_type, data_size, data_start_position, bb.position, bb
+                )
+                bb.set_position(array_end)
 
             return prop, start_values_pos
 
@@ -549,17 +579,19 @@ class ArkProperty:
                 ArkSaveLogger.parser_log(f"Reading struct {struct_type} with data size {data_size}")
                 return _STRUCT_READERS[ark_struct_type](bb, data_size)
             if in_array:
+                # No dedicated reader for this struct type. Fall through to the
+                # generic property-list read below — the designed backup for unknown
+                # structs in arrays. It reads cleanly for well-formed, None-terminated
+                # property-list structs, and read_array_property validates the array's
+                # total size and recovers from any type it can't fully consume, so
+                # this is not by itself an error. Record the type once (quietly) so it
+                # is discoverable without the noise of a per-type warning.
                 if struct_type not in UNSUPPORTED_STRUCTS:
-                    ArkSaveLogger.warning_log(f"Unsupported struct type {struct_type} in array")
+                    ArkSaveLogger.parser_log(
+                        f"No dedicated reader for struct '{struct_type}' in array; "
+                        f"reading generically as a property list"
+                    )
                     UNSUPPORTED_STRUCTS.append(struct_type)
-                
-                # uncomment the lines below if you want to make objects of unknown structs
-                # ArkSaveLogger.parser_log(f"Reading struct {struct_type} as array")
-                # bb.structured_print(to_default_file=True)
-                # bb.store()
-                # ArkSaveLogger.error_log(f"Unsupported struct type {struct_type} in array")
-                # ArkSaveLogger.open_hex_view(True)
-                # raise ValueError(f"Unsupported struct type {struct_type}")
 
         ArkSaveLogger.parser_log(f"Reading struct {struct_type} with data size {data_size} as property list at position {bb.get_position()}")
         # Fallback: struct as property list

{arkparse-0.5.2 → arkparse-0.5.3}/src/arkparse/saves/save_connection.py

@@ -182,7 +182,7 @@ class SaveConnection:
             obj_uuid = _fast_uuid_from_bytes(key_bytes)
             try:
                 reader = ArkBinaryParser(value_bytes, self.save_context)
-                class_name, _ = ArkGameObject.read_name(obj_uuid, reader)
+                class_name, *_ = ArkGameObject.read_name(obj_uuid, reader)
                 self._class_cache[obj_uuid] = class_name
             except Exception:
                 pass
@@ -192,7 +192,7 @@ class SaveConnection:
             return self._class_cache[obj_uuid]
         bin = self.get_game_obj_binary(obj_uuid)
         reader = ArkBinaryParser(bin, self.save_context)
-        class_name, string_name = ArkGameObject.read_name(obj_uuid, reader)
+        class_name, *_ = ArkGameObject.read_name(obj_uuid, reader)
         self._class_cache[obj_uuid] = class_name
         return class_name
 
@@ -402,7 +402,10 @@ class SaveConnection:
             cursor = conn.execute(query)
             for row in cursor:
                 byte_buffer = ArkBinaryParser(row[0], self.save_context)
-                class_name = byte_buffer.read_name()
+                # String-name-aware read: some objects store their class as an
+                # inline string instead of a name-table id, which a raw
+                # read_name() can't resolve (raises when generate_unknown is off).
+                class_name, *_ = ArkGameObject.read_name(None, byte_buffer)
                 if class_name not in classes:
                     classes.append(class_name)
         return classes
@@ -452,7 +455,7 @@ class SaveConnection:
         bin = self.get_game_obj_binary(obj_uuid)
         reader = ArkBinaryParser(bin, self.save_context)
 
-        class_name, string_name = ArkGameObject.read_name(obj_uuid, reader)
+        class_name, *_ = ArkGameObject.read_name(obj_uuid, reader)
 
         obj = SaveConnection.parse_as_predefined_object(obj_uuid, class_name, reader)
 
@@ -488,7 +491,7 @@ class SaveConnection:
                     continue
 
                 byte_buffer = ArkBinaryParser(binary_data, self.save_context)
-                class_name, _ = ArkGameObject.read_name(obj_uuid, byte_buffer)
+                class_name, *_ = ArkGameObject.read_name(obj_uuid, byte_buffer)
 
                 if reader_config.blueprint_name_filter and not reader_config.blueprint_name_filter(class_name):
                     continue