arkparse 0.5.2__tar.gz → 0.5.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparse
-Version: 0.5.2
+Version: 0.5.4
 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.4}/pyproject.toml

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

{arkparse-0.5.2 → arkparse-0.5.4}/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.4/src/arkparse/assets/make_composite.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""
+make_composite.py
+
+Downloads map tiles from a tile server and composites them into a single image.
+Auto-detects grid size using binary search.
+
+Requires: Pillow (PIL)
+  pip install pillow
+"""
+from __future__ import annotations
+
+import io
+import os
+import sys
+from typing import List
+from urllib.request import urlopen, Request
+from urllib.error import HTTPError
+from pathlib import Path
+
+try:
+    from PIL import Image
+except Exception as e:
+    print("Pillow is required: pip install pillow", file=sys.stderr)
+    raise
+
+# Headers to mimic a browser request
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
+    "Referer": "https://wikily.gg/",
+}
+
+TILE_SIZE = 256
+
+
+def tile_exists(base_url: str, zoom: int, x: int, y: int) -> bool:
+    """Check if a tile exists at the given coordinates."""
+    url = f"{base_url}/{zoom}/{x}/{y}.png"
+    try:
+        req = Request(url, headers=HEADERS, method='HEAD')
+        with urlopen(req, timeout=10) as resp:
+            return resp.status == 200
+    except HTTPError:
+        return False
+    except Exception:
+        # Try GET as fallback (some servers don't support HEAD)
+        try:
+            req = Request(url, headers=HEADERS)
+            with urlopen(req, timeout=10) as resp:
+                return resp.status == 200
+        except:
+            return False
+
+
+def find_grid_size(base_url: str, zoom: int) -> int:
+    """
+    Binary search to find the grid size (number of tiles per side).
+    Assumes square grid starting at 0,0.
+    """
+    print(f"Detecting grid size for zoom {zoom}...")
+    
+    # First, verify tile 0,0 exists
+    if not tile_exists(base_url, zoom, 0, 0):
+        raise SystemExit(f"Tile 0,0 does not exist at {base_url}/{zoom}/")
+    
+    # Binary search for max coordinate
+    low, high = 1, 256  # reasonable upper bound
+    
+    # First find an upper bound that doesn't exist
+    while tile_exists(base_url, zoom, high - 1, 0):
+        high *= 2
+        if high > 1024:
+            raise SystemExit("Grid size exceeds reasonable limit (1024)")
+    
+    # Binary search
+    while low < high:
+        mid = (low + high) // 2
+        if tile_exists(base_url, zoom, mid, 0):
+            low = mid + 1
+        else:
+            high = mid
+    
+    grid_size = low
+    print(f"Detected grid size: {grid_size}x{grid_size} tiles")
+    return grid_size
+
+
+def download_image(url: str) -> Image.Image:
+    """Download an image from URL and return as PIL Image."""
+    req = Request(url, headers=HEADERS)
+    with urlopen(req, timeout=30) as resp:
+        data = resp.read()
+    return Image.open(io.BytesIO(data)).convert("RGBA")
+
+
+def compose_map(base_url: str, zoom: int, out_path: str) -> None:
+    """Download all tiles for a zoom level and compose into single image."""
+    grid_size = find_grid_size(base_url, zoom)
+    
+    width = grid_size * TILE_SIZE
+    height = grid_size * TILE_SIZE
+    total_tiles = grid_size * grid_size
+    
+    print(f"Canvas size: {width}x{height} ({total_tiles} tiles)")
+    
+    canvas = Image.new("RGBA", (width, height), (0, 0, 0, 0))
+    
+    downloaded = 0
+    failed = 0
+    
+    for y in range(grid_size):
+        for x in range(grid_size):
+            tile_num = y * grid_size + x + 1
+            url = f"{base_url}/{zoom}/{x}/{y}.png"
+            print(f"Downloading tile {tile_num}/{total_tiles}: {zoom}/{x}/{y}.png", end="")
+            
+            try:
+                img = download_image(url)
+                if img.size != (TILE_SIZE, TILE_SIZE):
+                    img = img.resize((TILE_SIZE, TILE_SIZE))
+                
+                paste_x = x * TILE_SIZE
+                paste_y = y * TILE_SIZE
+                canvas.paste(img, (paste_x, paste_y))
+                downloaded += 1
+                print(" OK")
+            except Exception as e:
+                print(f" FAILED: {e}")
+                failed += 1
+    
+    print(f"\nDownloaded: {downloaded}, Failed: {failed}")
+    
+    # Save
+    os.makedirs(os.path.dirname(out_path) or ".", exist_ok=True)
+    canvas.convert("RGB").save(out_path, format="PNG")
+    print(f"Saved -> {out_path}")
+
+
+def main() -> None:
+    # Configuration
+    output_dir = Path(__file__).parent
+    zoom = 5
+    
+    # List of maps to download: (base_url, output_name)
+    maps: List[tuple[str, str]] = [
+        ("https://r2.wikily.gg/images/ark/maps/lost_colony_tiles", "LOST_COLONY.png"),
+        ("https://r2.wikily.gg/images/ark/maps/valguero_tiles", "VALGUERO.png"),
+        ("https://r2.wikily.gg/images/ark/maps/aberration_tiles", "ABERRATION.png"),
+        ("https://r2.wikily.gg/images/ark/maps/ragnarok_tiles", "RAGNAROK.png"),
+        ("https://r2.wikily.gg/images/ark/maps/the_island_tiles", "THE_ISLAND.png"),
+        ("https://r2.wikily.gg/images/ark/maps/genesis_tiles", "GENESIS_BIOMES.png"),
+        ("https://r2.wikily.gg/images/ark/maps/genesisocean_tiles", "GENESIS_OCEAN.png"),
+    ]
+    
+    for base_url, output_name in maps:
+        print(f"\n{'='*60}")
+        print(f"Processing: {output_name}")
+        print(f"Base URL: {base_url}")
+        print(f"Zoom: {zoom}")
+        print('='*60)
+        
+        out_path = os.path.join(output_dir, output_name)
+        try:
+            compose_map(base_url, zoom, out_path)
+        except Exception as e:
+            print(f"ERROR processing {output_name}: {e}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

{arkparse-0.5.2 → arkparse-0.5.4}/src/arkparse/classes/dinos.py

@@ -139,7 +139,11 @@ class DlcDinos:
     malwyn = "/Game/LostColony/Dinos/SnowDragon/SnowDragon_Character_BP.SnowDragon_Character_BP_C"
     ossidon = "/Game/LostColony/Dinos/SnowMonster/SnowMonster_Character_BP.SnowMonster_Character_BP_C"
     gloon = "/Game/LostColony/Dinos/LostChargePet/LostCharge_LanternPet_Char_BP.LostCharge_LanternPet_Char_BP_C"
-    all_bps = [firemane, archelon, dread_mare, oasisaur, train, helper_bot, zeppelin, doggo, veilwyn, elderclaw, solwyn, malwyn, ossidon, gloon]
+    lumina = "/Game/Dragontopia/Dragons/Eclipsar/Lumina/Lumina_Character_BP.Lumina_Character_BP_C"
+    umbra = "/Game/Dragontopia/Dragons/Eclipsar/Umbra/Umbra_Character_BP.Umbra_Character_BP_C"
+    brig_ship = "/Game/Water/Vessels/Brig/BrigShipBP.BrigShipBP_C"
+    sloop_ship = "/Game/Water/Vessels/Sloop/SloopShipBP.SloopShipBP_C"
+    all_bps = [firemane, archelon, dread_mare, oasisaur, train, helper_bot, zeppelin, doggo, veilwyn, elderclaw, solwyn, malwyn, ossidon, gloon, lumina, umbra, brig_ship, sloop_ship]
 
 class ShoulderPets:
     glowtail = "/Game/Aberration/Dinos/LanternLizard/LanternLizard_Character_BP.LanternLizard_Character_BP_C"
@@ -223,6 +227,8 @@ class NonTameable:
     tek_giga = "/Game/PrimalEarth/Dinos/Giganotosaurus/BionicGigant_Character_BP.BionicGigant_Character_BP_C"
     leedsichthys = "/Game/PrimalEarth/Dinos/Leedsichthys/Leedsichthys_Character_BP.Leedsichthys_Character_BP_C"
     yeti = "/Game/PrimalEarth/Dinos/Bigfoot/Yeti_Character_BP.Yeti_Character_BP_C"
+    insect_swarm = "/Game/Genesis/Dinos/Swarms/InsectSwarmChar_BP.InsectSwarmChar_BP_C"
+    microbe_swarm = "/Game/Genesis/Dinos/Swarms/MicrobeSwarmChar_BP.MicrobeSwarmChar_BP_C"
     corrupted = Corrupted()
     alpha = Alphas()
     event = event()
@@ -233,7 +239,7 @@ class NonTameable:
         coelacanth_ocean, leech, leech_diseased, piranha, 
         sabertooth_salmon, trilobite, death_worm, jugbug_oil, jugbug_water,
         enforcer, scout, defence_unit, polar_bear, iceworm, tek_giga,
-        leedsichthys, yeti
+        leedsichthys, yeti, insect_swarm, microbe_swarm
     ] + corrupted.all_bps + alpha.all_bps + event.all_bps
 
 class Paleo:
@@ -382,6 +388,7 @@ class Dinos:
     helicoprion = "/Game/ASA/Dinos/Helicoprion/Helicoprion_Character_BP.Helicoprion_Character_BP_C"
     acrocanthosaurus = "/Game/ASA/Dinos/Acrocanthosaurus/Acrocanthosaurus_Character_BP.Acrocanthosaurus_Character_BP_C"
     cryolophosaurus = "/Game/ASA/Dinos/Cryolophosaurus/Cryolophosaurus_Character_BP.Cryolophosaurus_Character_BP_C"
+    magmasaur = "/Game/Genesis/Dinos/Cherufe/Cherufe_Character_BP"
 
     abberant = Abberant()
     paleo = Paleo()
@@ -416,7 +423,7 @@ class Dinos:
         dreadnoughtus, maelizard, shastasaurus, gacha, gasbag,
         managarmr, tek_raptor, tek_rex, tek_stego,
         velonosaur, yutyrannus, tek_parasaur, queen_bee,
-        rubble_golem, helicoprion, acrocanthosaurus, cryolophosaurus
+        rubble_golem, helicoprion, acrocanthosaurus, cryolophosaurus, magmasaur
     ]  + abberant.all_bps + flyers.all_bps + \
         dlc_dinos.all_bps + shoulder_pets.all_bps + non_tameable.all_bps + \
         paleo.all_bps

{arkparse-0.5.2 → arkparse-0.5.4}/src/arkparse/classes/placed_structures.py

@@ -96,8 +96,9 @@ class Crafting:
     cooking_pot = "/Game/PrimalEarth/Structures/CookingPot.CookingPot_C"
     grill = "/Game/PrimalEarth/Structures/Grill.Grill_C"
     chembench = "/Game/PrimalEarth/Structures/StorageBox_ChemBench.StorageBox_ChemBench_C"
+    blood_forge = "/Game/LostColony/Structures/Bloodforge/Inventory/InventoryComponent_Bloodforge.InventoryComponent_Bloodforge_C"
 
-    all_bps = [forge, mortar_and_pestle, compost_bin, campfire, cooking_pot, grill, chembench]
+    all_bps = [forge, mortar_and_pestle, compost_bin, campfire, cooking_pot, grill, chembench, blood_forge]
 
 class Utility:
     simple_bed = "/Game/PrimalEarth/Structures/SimpleBed.SimpleBed_C"
@@ -112,9 +113,11 @@ class Utility:
     toilet = "/Game/PrimalEarth/Structures/Furniture/StructureBP_Toilet.StructureBP_Toilet_C"
     cryofridge = "/Game/Extinction/Structures/Cryofridge/CryoFridge.CryoFridge_C"
     deathitemcache = "/Game/PrimalEarth/Structures/DeathItemCache.DeathItemCache_C"
+    cryo_hospital = "/Game/LostColony/Structures/CryoHospital/Inventory/InventoryComponent_CryoHospital.InventoryComponent_CryoHospital_C"
+    medical_stand = "/Game/LostColony/Structures/MedicalStand/Inventories/InventoryComponent_MedicalStand.InventoryComponent_MedicalStand_C"
 
     all_bps = [simple_bed, sleeping_bag, anvil_bench, small_storage_box, large_bear_trap, large_storage_box,
-               bunk_bed, vault, sleeping_pod, toilet, cryofridge, deathitemcache]
+               bunk_bed, vault, sleeping_pod, toilet, cryofridge, deathitemcache, cryo_hospital, medical_stand]
     
 class TributeTerminals:
     tribute_terminal_purple = "/Game/PrimalEarth/Structures/TributeTerminal_Purple.TributeTerminal_Purple_C"

{arkparse-0.5.2 → arkparse-0.5.4}/src/arkparse/enums/ark_map.py

@@ -15,10 +15,18 @@ class ArkMap(Enum):
     SVARTALFHEIM = 11
     CLUB_ARK = 12
     LOST_COLONY = 13
+    GENESIS1 = 14
 
     def to_file_name(self) -> str:
         """
         Converts the enum value to a file name.
         :return: The file name of the map.
         """
-        return self.name.replace('_', ' ').title().replace(' ', '')
+        return self.name.replace('_', ' ').title().replace(' ', '')
+    
+class SubMap(Enum):
+    pass
+
+class GenesisSubMap(Enum):
+    BIOMES = "OtherBiomes"
+    OCEAN = "Ocean"

{arkparse-0.5.2 → arkparse-0.5.4}/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.4}/src/arkparse/object_model/dinos/dino.py

@@ -267,7 +267,7 @@ class Dino(ParsedObjectBase):
 
         # Grab gene traits if they exists
         if self.gene_traits is not None:
-            json_obj["GeneTraits"] = self.gene_traits
+            json_obj["GeneTraits"] = [str(t) for t in self.gene_traits]
 
         # Grab colors if they exists
         color_set_indices = self.get_color_set_indices()

{arkparse-0.5.2 → arkparse-0.5.4}/src/arkparse/parsing/_base_value_parser.py

@@ -1,6 +1,6 @@
 import struct
 from typing import List
-from uuid import UUID
+from uuid import UUID, SafeUUID
 
 from ._binary_reader_base import BinaryReaderBase
 from arkparse.logging import ArkSaveLogger
@@ -24,6 +24,7 @@ def _fast_uuid_from_bytes(b: bytes) -> UUID:
     # This is ~3-4x faster than UUID(bytes=b)
     u = object.__new__(UUID)
     object.__setattr__(u, 'int', int.from_bytes(b, 'big'))
+    object.__setattr__(u, 'is_safe', SafeUUID.unknown)
     return u
     
 class BaseValueParser(BinaryReaderBase):

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

@@ -11,6 +11,7 @@ from arkparse.parsing.struct.ark_linear_color import ArkLinearColor
 from arkparse.parsing.struct.ark_quat import ArkQuat
 from arkparse.parsing.struct.ark_rotator import ArkRotator
 from arkparse.parsing.struct.ark_vector import ArkVector
+from arkparse.parsing.struct.ark_vector2d import ArkVector2D
 from arkparse.parsing.struct.ark_unique_net_id_repl import ArkUniqueNetIdRepl
 from arkparse.parsing.struct.ark_vector_bool_pair import ArkVectorBoolPair
 from arkparse.parsing.struct.ark_server_custom_folder import ArkServerCustomFolder
@@ -83,6 +84,7 @@ _STRUCT_READERS: Dict[ArkStructType, Callable[["ArkBinaryParser", int], Any]] =
     ArkStructType.Quat: lambda bb, ds: ArkQuat(bb),
     ArkStructType.Rotator: lambda bb, ds: ArkRotator(bb),
     ArkStructType.Vector: lambda bb, ds: ArkVector(bb),
+    ArkStructType.Vector2D: lambda bb, ds: ArkVector2D(bb, ds),
     ArkStructType.UniqueNetIdRepl: lambda bb, ds: ArkUniqueNetIdRepl(bb),
     ArkStructType.VectorBoolPair: lambda bb, ds: ArkVectorBoolPair(bb),
     ArkStructType.ArkTrackedActorIdCategoryPairWithBool: lambda bb, ds: ArkTrackedActorIdCategoryPairWithBool(bb),
@@ -397,6 +399,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 +440,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 +581,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.4}/src/arkparse/parsing/struct/__init__.py

@@ -11,6 +11,7 @@ from .ark_tracked_actor_id_category_pair import ArkTrackedActorIdCategoryPair
 from .ark_unique_net_id_repl import ArkUniqueNetIdRepl
 from .ark_vector_bool_pair import ArkVectorBoolPair
 from .ark_vector import ArkVector
+from .ark_vector2d import ArkVector2D
 from .object_reference import ObjectReference, get_uuid_reference_bytes
 from .unknown_struct import UnknownStruct
 from .ark_custom_item_data import ArkCustomItemData