arkparse 0.3.9__tar.gz → 0.4.1__tar.gz

{arkparse-0.3.9 → arkparse-0.4.1}/.gitignore

@@ -183,4 +183,5 @@ temp
 **/temp_files/**
 **/temp_files**
 **/exports/**
-**/**.ark.gz
+**/**.ark.gz
+/src/.idea

{arkparse-0.3.9 → arkparse-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparse
-Version: 0.3.9
+Version: 0.4.1
 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.3.9 → arkparse-0.4.1}/pyproject.toml

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

{arkparse-0.3.9 → arkparse-0.4.1}/src/arkparse/api/dino_api.py

@@ -29,13 +29,18 @@ class DinoApi:
         blueprint_name_filter=lambda name: \
             name is not None and \
                 (("Dinos/" in name and "_Character_" in name) or \
-                ("PrimalItem_WeaponEmptyCryopod" in name)))
+                ("PrimalItem_WeaponEmptyCryopod" in name or "PrimalItem_SCSCryopod" in name)))
 
     def __init__(self, save: AsaSave):
         self.save = save
         self.all_objects = None
         self.parsed_dinos: Dict[UUID, Dino] = {}
         self.parsed_cryopods: Dict[UUID, Cryopod] = {}
+
+    @staticmethod
+    def is_applicable_bp(blueprint: str) -> bool:
+        return DinoApi._DEFAULT_CONFIG.blueprint_name_filter(blueprint)
+
     def get_all_objects(self, config: GameObjectReaderConfiguration = None) -> Dict[UUID, ArkGameObject]:
         reuse = False
 
@@ -114,7 +119,7 @@ class DinoApi:
                             dino = Dino(obj.uuid, save=self.save)
                         self.parsed_dinos[obj.uuid] = dino
 
-                elif "PrimalItem_WeaponEmptyCryopod" in obj.blueprint and include_cryos and include_tamed:
+                elif ("PrimalItem_SCSCryopod" in obj.blueprint or "PrimalItem_WeaponEmptyCryopod" in obj.blueprint) and include_cryos and include_tamed:
                     if not obj.get_property_value("bIsEngram", default=False) and obj.get_property_value("CustomItemDatas") is not None:
                         if obj.uuid in self.parsed_cryopods:
                             is_baby = self.parsed_cryopods[obj.uuid].dino is not None and isinstance(self.parsed_cryopods[obj.uuid].dino, TamedBaby)
@@ -203,7 +208,7 @@ class DinoApi:
 
     def get_all_by_class(self, class_names: List[str], include_cryopodded: bool = True) -> Dict[UUID, Dino]:
         config = GameObjectReaderConfiguration(
-            blueprint_name_filter=lambda name: name is not None and ((name in class_names) or (include_cryopodded and ("PrimalItem_WeaponEmptyCryopod" in name)))
+            blueprint_name_filter=lambda name: name is not None and ((name in class_names) or (include_cryopodded and ("PrimalItem_WeaponEmptyCryopod" in name or "PrimalItem_SCSCryopod" in name)))
         )
 
         dinos = self.get_all(config, include_cryos=include_cryopodded)

{arkparse-0.3.9 → arkparse-0.4.1}/src/arkparse/api/equipment_api.py

@@ -16,6 +16,13 @@ from arkparse.classes.equipment import Equipment as EqClasses
 from .general_api import GeneralApi
 
 class EquipmentApi(GeneralApi):
+    _DEFAULT_CONFIG = GameObjectReaderConfiguration(
+            blueprint_name_filter=lambda name: name is not None and \
+                        (("Weapons" in name and ("PrimalItemAmmo" not in name) and ("PrimalItem_WeaponEmptyCryopod" not in name)) or \
+                            "Armor" in name or \
+                            name in (EqClasses.weapons.all_bps + EqClasses.shield.all_bps + EqClasses.saddles.all_bps + EqClasses.armor.all_bps))
+    )
+
     class Classes:
         WEAPON = Weapon
         SADDLE = Saddle
@@ -23,16 +30,27 @@ class EquipmentApi(GeneralApi):
         SHIELD = Shield
 
     def __init__(self, save: AsaSave):
-        config = GameObjectReaderConfiguration(
-            blueprint_name_filter=lambda name: name is not None and \
-                                               (("Weapons" in name and "PrimalItemAmmo" not in name) or \
-                                                 "Armor" in name or \
-                                                 name in EqClasses.all_bps)
-                                                 
-        )
+        config = EquipmentApi._DEFAULT_CONFIG
         super().__init__(save, config)
         self.parsed_objects: Dict[UUID, Equipment] = {}
 
+    @staticmethod
+    def bp_to_class(blueprint: str):
+        if blueprint in EqClasses.weapons.all_bps or ("/Weapons/" in blueprint):
+            return EquipmentApi.Classes.WEAPON
+        elif blueprint in EqClasses.saddles.all_bps or ("/Saddles/" in blueprint):
+            return EquipmentApi.Classes.SADDLE
+        elif blueprint in EqClasses.shield.all_bps or ("/Armor/Shields/" in blueprint):
+            return EquipmentApi.Classes.SHIELD
+        elif blueprint in EqClasses.armor.all_bps or ("/Armor/" in blueprint):
+            return EquipmentApi.Classes.ARMOR
+        else:
+            return None
+
+    @staticmethod
+    def is_applicable_bp(blueprint: str) -> bool:
+        return EquipmentApi._DEFAULT_CONFIG.blueprint_name_filter(blueprint)
+
     def __get_cls_filter(self, cls: "EquipmentApi.Classes"):
         if cls == self.Classes.WEAPON:
             return EqClasses.weapons.all_bps

{arkparse-0.3.9 → arkparse-0.4.1}/src/arkparse/api/json_api.py

@@ -320,6 +320,33 @@ class JsonApi:
 
         ArkSaveLogger.api_log("Players successfully exported.")
 
+    def export_cluster_data(self, player_api: PlayerApi = None, cluster_data_dir: str = None, export_folder_path: str = Path.cwd() / "json_exports"):
+        ArkSaveLogger.api_log("Exporting cluster data...")
+
+        # Get player API if not provided.
+        if player_api is None:
+            player_api = PlayerApi(self.save, self.ignore_error, cluster_data_dir=cluster_data_dir)
+
+        all_cluster_data = []
+        for unique_id, cluster_data in player_api.cluster_data.items():
+            cluster_data_json_obj = {
+                "PlayerUniqueID": unique_id.__str__(),
+                "Dinos": [dino.to_json_obj() for dino in cluster_data.dinos],
+                "Items": [item.to_json_obj() for item in cluster_data.items]
+            }
+            all_cluster_data.append(cluster_data_json_obj)
+
+        # Create json exports folder if it does not exist.
+        path_obj = Path(cluster_data_dir) if cluster_data_dir is not None else Path(export_folder_path)
+        if not (path_obj.exists() and path_obj.is_dir()):
+            path_obj.mkdir(parents=True, exist_ok=True)
+
+        # Write JSON.
+        with open(path_obj / "cluster_data.json", "w") as text_file:
+            text_file.write(json.dumps(all_cluster_data, default=lambda o: o.to_json_obj() if hasattr(o, 'to_json_obj') else None, indent=4, cls=DefaultJsonEncoder))
+
+        ArkSaveLogger.api_log("Cluster data successfully exported.")
+
     def export_tribes(self, player_api: PlayerApi = None, export_folder_path: str = Path.cwd() / "json_exports", include_players_data: bool = False):
         ArkSaveLogger.api_log("Exporting tribes...")
 
@@ -506,3 +533,4 @@ class JsonApi:
         self.export_player_pawns(player_api=player_api, export_folder_path=export_folder_path)
         self.export_players(player_api=player_api, export_folder_path=export_folder_path)
         self.export_tribes(player_api=player_api, export_folder_path=export_folder_path)
+        self.export_cluster_data(player_api=player_api, export_folder_path=export_folder_path)

{arkparse-0.3.9 → arkparse-0.4.1}/src/arkparse/api/player_api.py

@@ -1,5 +1,5 @@
 import uuid
-from typing import List, Dict, Optional
+from typing import List, Dict, Optional, TYPE_CHECKING
 from pathlib import Path
 from uuid import UUID
 
@@ -17,6 +17,9 @@ from arkparse.object_model.misc.dino_owner import DinoOwner
 from arkparse.object_model.misc.object_owner import ObjectOwner
 from arkparse.object_model.ark_game_object import ArkGameObject
 
+if TYPE_CHECKING:
+    from arkparse.object_model.cluster_data.ark_cluster_data import ClusterData
+
 class _TribeAndPlayerData:
     HEADER_OFFSET_ADJUSTMENT = 4
     TRIBE_HEADER_BASE_OFFSET = 4
@@ -121,12 +124,13 @@ class PlayerApi:
         OBJECT = 0
         DINO = 1
 
-    def __init__(self, save: AsaSave, ignore_error: bool = False, no_pawns: bool = False, bypass_inventory: bool = False, pawn_objects: Optional[list[ArkGameObject]] = None, force_legacy_store: bool = False):
+    def __init__(self, save: AsaSave, ignore_error: bool = False, no_pawns: bool = False, bypass_inventory: bool = False, pawn_objects: Optional[list[ArkGameObject]] = None, force_legacy_store: bool = False, cluster_data_dir: Optional[Path] = None):
         self.players: List[ArkPlayer] = []
         self.tribes: List[ArkTribe] = []
         self.tribe_to_player_map: Dict[int, List[ArkPlayer]] = {}
         self.save: AsaSave = save
         self.pawns: Optional[Dict[UUID, ArkGameObject]] = None
+        self.cluster_data: Optional[Dict[str, "ClusterData"]] = {}
 
         self.profile_paths: List[Path] = []
         self.tribe_paths: List[Path] = []
@@ -162,6 +166,8 @@ class PlayerApi:
         ArkSaveLogger.api_log("Parsing player and tribe data from files")
         self.__update_files(bypass_inventory)
 
+        self._get_cluster_data_from_directory(cluster_data_dir)
+
     def __del__(self):
         ArkSaveLogger.api_log("Stopping PlayerApi")
         self.players = {}
@@ -178,6 +184,14 @@ class PlayerApi:
                 blueprint_name_filter=lambda name: name is not None and name in pawn_bps,
             )
             self.pawns = self.save.get_game_objects(config)
+    
+    def __find_cluster_data_file_in_save_dir(self, player: ArkPlayer) -> Optional[Path]:
+        if self.save is not None and self.save.save_dir is not None:
+            expected_file_name = f"{player.unique_id}"
+            expected_path = self.save.save_dir / expected_file_name
+            if expected_path.exists():
+                return expected_path
+        return None
 
     def __store_as_file(self, data: bytes, file_name: str):
         output_dir = TEMP_FILES_DIR
@@ -208,6 +222,28 @@ class PlayerApi:
             self.profile_paths.append(path)
         for path in directory.glob("*.arktribe"):
             self.tribe_paths.append(path)
+    
+    def _get_cluster_data_from_directory(self, directory: Path = None) -> Optional["ClusterData"]:
+        from arkparse.object_model.cluster_data.ark_cluster_data import ClusterData
+        def get_files(path: Path) -> list[Path]:
+            return [f for f in path.iterdir() if (f.is_file() and not f.name.endswith(".py"))]
+
+        all_data = {}
+        files = get_files(directory) if directory is not None else []
+
+        if len(files) == 0:
+            directory = self.save.save_dir if self.save is not None else None
+            for player in self.players:
+                path = self.__find_cluster_data_file_in_save_dir(player)
+                if path is not None:
+                    files.append(path)
+
+        for file in files:
+            ArkSaveLogger.info_log(f"Found file: {file.name}")
+            cluster_data = ClusterData(directory, file.name)
+            all_data[file.name] = cluster_data
+
+        self.cluster_data = all_data
 
     def __update_files(self, bypass_inventory: bool):
         new_players: Dict[int, ArkPlayer] = {}
@@ -327,6 +363,21 @@ class PlayerApi:
                 return t
         return None
     
+    def get_cluster_data(self, player: ArkPlayer):
+        if self.cluster_data is None:
+            return None
+        
+        if player.unique_id in self.cluster_data:
+            return self.cluster_data[player.unique_id]
+        return None
+    
+    def get_players_with_cluster_data(self):
+        players_with_data = []
+        for player in self.players:
+            if self.get_cluster_data(player) is not None:
+                players_with_data.append(player)
+        return players_with_data
+    
     def get_player_with(self, stat: int, stat_type: int = StatType.HIGHEST):
         istat = self.__get_stat(stat)
         player: Optional[ArkPlayer] = None

{arkparse-0.3.9 → arkparse-0.4.1}/src/arkparse/api/stackable_api.py

@@ -13,10 +13,16 @@ class StackableApi(GeneralApi):
         RESOURCE = Resource
         AMMO = Ammo
 
+    _DEFAULT_CONFIG = GameObjectReaderConfiguration(
+            blueprint_name_filter=lambda name: name is not None and ("Resources/PrimalItemResource" in name or "/PrimalItemConsumable" in name or "PrimalItemAmmo" in name)
+    )
+
+    @staticmethod
+    def is_applicable_bp(blueprint: str) -> bool:
+        return StackableApi._DEFAULT_CONFIG.blueprint_name_filter(blueprint)
+
     def __init__(self, save: AsaSave):
-        config = GameObjectReaderConfiguration(
-            blueprint_name_filter=lambda name: name is not None and "Resources/PrimalItemResource" in name or "/PrimalItemConsumable" in name
-        )
+        config = StackableApi._DEFAULT_CONFIG
         super().__init__(save, config)
     
     def get_all(self, cls: "StackableApi.Classes", config = None) -> Dict[UUID, InventoryItem]:

{arkparse-0.3.9 → arkparse-0.4.1}/src/arkparse/classes/equipment.py

@@ -5,7 +5,7 @@ class Saddles:
     ceratosaurus: str = "/Game/ASA/Dinos/Ceratosaurus/Dinos/Saddle/PrimalItemArmor_CeratosaurusSaddle_ASA.PrimalItemArmor_CeratosaurusSaddle_ASA_C"
     deinosuchus: str = "/Game/ASA/Dinos/Deinosuchus/Saddle/PrimalItemArmor_Deinosuchus_Saddle_ASA.PrimalItemArmor_Deinosuchus_Saddle_ASA_C"
     fasolasuchus: str = "/Game/ASA/Dinos/Fasolasuchus/PrimalItemArmor_FasolaSaddle.PrimalItemArmor_FasolaSaddle_C"
-    gigantoraptor: str = "/Game/ASA/Dinos/Gigantoraptor/PrimalItemArmor_GigantoraptorSaddle.PrimalItemArmor_GigantoraptorSaddle_C"
+    gigantoraptor_ASA: str = "/Game/ASA/Dinos/Gigantoraptor/PrimalItemArmor_GigantoraptorSaddle.PrimalItemArmor_GigantoraptorSaddle_C"
     shastasaurus: str = "/Game/ASA/Dinos/Shastasaurus/PrimalItemArmor_ShastaSaddle_Submarine.PrimalItemArmor_ShastaSaddle_Submarine_C"
     xiphactinus: str = "/Game/ASA/Dinos/Xiphactinus/Dinos/Saddle/PrimalItemArmor_XiphSaddle_ASA.PrimalItemArmor_XiphSaddle_ASA_C"
     helicoprion: str = "/Game/ASA/Dinos/Helicoprion/Saddle/PrimalItemArmor_Helicoprion.PrimalItemArmor_Helicoprion_C"
@@ -106,8 +106,9 @@ class Saddles:
     ravager: str = "/Game/Aberration/Dinos/CaveWolf/PrimalItemArmor_CavewolfPromoSaddle.PrimalItemArmor_CavewolfPromoSaddle_C"
     managarmr: str = "/Game/Extinction/CoreBlueprints/Items/Saddle/PrimalItemArmor_IceJumperSaddle.PrimalItemArmor_IceJumperSaddle_C"
     velonosaur: str = "/Game/Extinction/CoreBlueprints/Items/Saddle/PrimalItemArmor_SpindlesSaddle.PrimalItemArmor_SpindlesSaddle_C"
+    gigantoraptor: str = "/Gigantoraptor/Gigantoraptor/PrimalItemArmor_GigantoraptorSaddle.PrimalItemArmor_GigantoraptorSaddle_C"
 
-    all_bps = [yi_ling, archelon, ceratosaurus, deinosuchus, fasolasuchus, gigantoraptor, 
+    all_bps = [yi_ling, archelon, ceratosaurus, deinosuchus, fasolasuchus, gigantoraptor_ASA, 
                shastasaurus, xiphactinus, saddle_cart_btt, rockdrake_btt, allo, ankylo, 
                argentavis, arthro, baryonyx, basilo, castoroides, carcha, carno, chalico, 
                daeodon, diplodocus, dire_bear, doedi, dolphin, dunkleosteus, equus, gallimimus, 
@@ -120,7 +121,7 @@ class Saddles:
                titanosaur_platform, beelzebufo, trike, carbo, tuso, yuty, basilisk, cave_wolf,
                karkinos, mole_rat, rock_drake, rock_drake_tek, camel, mantis, moth, rock_golem,
                thorny_dragon, bison, deinotherium, dreadnoughtus, maelizard, gacha, gas_bags,
-               snow_owl, ravager, managarmr, velonosaur, helicoprion]
+               snow_owl, ravager, managarmr, velonosaur, helicoprion, gigantoraptor]
     
 class Hazard:
     boots: str = "/Game/Aberration/CoreBlueprints/Items/Armor/HazardSuit/PrimalItemArmor_HazardSuitBoots.PrimalItemArmor_HazardSuitBoots_C"
@@ -350,6 +351,30 @@ class Weapons:
 
     all_bps = gathering.all_bps + primitive.all_bps + advanced.all_bps 
 
+class Mek:
+    shield: str = "/Game/Extinction/CoreBlueprints/Items/Saddle/PrimalItemArmor_MekBackpack_Shield.PrimalItemArmor_MekBackpack_Shield_C"
+    cannon: str = "/Game/Extinction/CoreBlueprints/Items/Saddle/PrimalItemArmor_MekBackpack_SiegeCannon.PrimalItemArmor_MekBackpack_SiegeCannon_C"
+    missile_pod: str = "/Game/Extinction/CoreBlueprints/Items/Saddle/PrimalItemArmor_MekBackpack_MissilePod.PrimalItemArmor_MekBackpack_MissilePod_C"
+    transformer: str = "/Game/Extinction/CoreBlueprints/Items/Saddle/PrimalItemArmor_MekTransformer.PrimalItemArmor_MekTransformer_C"
+
+    all_bps = [shield, cannon]
+
+class ArmaDoggoGear:
+    armor: str = "/Game/Packs/Wasteland/Dinos/Doggo/PrimalItemArmor_DinoCompanionSaddle_Doggo.PrimalItemArmor_DinoCompanionSaddle_Doggo_C"
+    ammo_box: str = "/Game/Packs/Wasteland/Dinos/CompanionDino/Items/Armor/PrimalItemArmor_DinoCompanion_Gear_AmmoBox.PrimalItemArmor_DinoCompanion_Gear_AmmoBox_C"
+    extra_armor: str = "/Game/Packs/Wasteland/Dinos/CompanionDino/Items/Armor/PrimalItemArmor_DinoCompanion_Gear_ExtraArmor.PrimalItemArmor_DinoCompanion_Gear_ExtraArmor_C"
+    speed_booster: str = "/Game/Packs/Wasteland/Dinos/CompanionDino/Items/Armor/PrimalItemArmor_DinoCompanion_Gear_Movespeed.PrimalItemArmor_DinoCompanion_Gear_Movespeed_C"
+    oxygen_tank: str = "/Game/Packs/Wasteland/Dinos/CompanionDino/Items/Armor/PrimalItemArmor_DinoCompanion_Gear_OxygenTank.PrimalItemArmor_DinoCompanion_Gear_OxygenTank_C"
+    rucksack: str = "/Game/Packs/Wasteland/Dinos/CompanionDino/Items/Armor/PrimalItemArmor_DinoCompanion_Gear_Bag.PrimalItemArmor_DinoCompanion_Gear_Bag_C"
+    medpack: str = "/Game/Packs/Wasteland/Dinos/CompanionDino/Items/Armor/PrimalItemArmor_DinoCompanion_Gear_Medkit.PrimalItemArmor_DinoCompanion_Gear_Medkit_C"
+    camping_gear: str = "/Game/Packs/Wasteland/Dinos/CompanionDino/Items/Armor/PrimalItemArmor_DinoCompanion_Gear_RolledUpSleepingBag.PrimalItemArmor_DinoCompanion_Gear_RolledUpSleepingBag_C"
+    picnic_set: str = "/Game/Packs/Wasteland/Dinos/CompanionDino/Items/Armor/PrimalItemArmor_DinoCompanion_Gear_FoodBasket.PrimalItemArmor_DinoCompanion_Gear_FoodBasket_C"
+    battle_spikes: str = "\Game\Packs\Wasteland\Dinos\CompanionDino\Items\Armor\PrimalItemArmor_DinoCompanion_Gear_Spikes.PrimalItemArmor_DinoCompanion_Gear_Spikes_C"
+    bait_trap: str = "/Game/Packs/Wasteland/Dinos/CompanionDino/Items/Armor/PrimalItemArmor_DinoCompanion_Gear_MeatSack.PrimalItemArmor_DinoCompanion_Gear_MeatSack_C"
+
+
+
+    all_bps = [armor]
 
 class Equipment:
     saddles = Saddles()
@@ -360,5 +385,7 @@ class Equipment:
     ammo = Ammo()
     misc: Misc = Misc()
     throwables: Throwables = Throwables()
+    mek: Mek = Mek()
+    arma_doggo_gear: ArmaDoggoGear = ArmaDoggoGear()
 
-    all_bps = saddles.all_bps + armor.all_bps + utilities.all_bps + weapons.all_bps + shield.all_bps + ammo.all_bps + misc.all_bps + throwables.all_bps
+    all_bps = saddles.all_bps + armor.all_bps + utilities.all_bps + weapons.all_bps + shield.all_bps + ammo.all_bps + misc.all_bps + throwables.all_bps + mek.all_bps + arma_doggo_gear.all_bps

{arkparse-0.3.9 → arkparse-0.4.1}/src/arkparse/logging/ark_save_logger.py

@@ -48,7 +48,10 @@ class ArkSaveLogger:
 
     @staticmethod
     def parser_log(message: str):
-        ArkSaveLogger.__log(message, ArkSaveLogger.LogTypes.PARSER, ArkSaveLogger.LogColors.CYAN)
+        struct_header = ""
+        for struct in ArkSaveLogger.current_struct_path:
+            struct_header += f"[{struct}]"
+        ArkSaveLogger.__log(struct_header + message, ArkSaveLogger.LogTypes.PARSER, ArkSaveLogger.LogColors.CYAN)
 
     @staticmethod
     def info_log(message: str):

{arkparse-0.3.9 → arkparse-0.4.1}/src/arkparse/object_model/ark_game_object.py

@@ -39,6 +39,9 @@ class ArkGameObject(ArkPropertyContainer):
 
     def __init__(self, uuid: Optional[UUID] = None, blueprint: Optional[str] = None, binary_reader: Optional[ArkBinaryParser|LegacyArkBinaryParser] = None, from_custom_bytes: bool = False, no_header: bool = False):
         self.parser_type = ArkProperty if (isinstance(binary_reader, ArkBinaryParser) or binary_reader is None) else LegacyArkProperty
+        self.uuid = uuid
+        self.blueprint = blueprint
+        string_name = False
         super().__init__()
         if binary_reader:
             ArkSaveLogger.set_file(binary_reader, "debug.bin")
@@ -49,7 +52,8 @@ class ArkGameObject(ArkPropertyContainer):
                     self.uuid2: UUID = None
                     binary_reader.set_position(0)
 
-                    self.blueprint = binary_reader.read_name()
+                    self.blueprint, string_name = ArkGameObject.read_name(uuid, binary_reader)
+                    ArkSaveLogger.parser_log(f"Read Blueprint: {self.blueprint} (String name: {string_name})")
 
                     sContext : SaveContext = binary_reader.save_context
                     self.location = sContext.get_actor_transform(uuid) or None
@@ -58,11 +62,14 @@ class ArkGameObject(ArkPropertyContainer):
                     self.uuid = binary_reader.read_uuid()
                     self.blueprint = binary_reader.read_string()
                     ArkSaveLogger.parser_log(f"Read UUID: {self.uuid}, Blueprint: {self.blueprint}")
-
+                
                 binary_reader.validate_uint32(0)
+                if string_name:
+                    binary_reader.read_uint16()
 
             try:
-                if not no_header:
+                if not (no_header or string_name):
+                    ArkSaveLogger.parser_log(f"Reading names for object {self.blueprint} ({self.uuid})")
                     offsets = []
                     if not from_custom_bytes:
                         nr_names = binary_reader.read_int()
@@ -97,7 +104,8 @@ class ArkGameObject(ArkPropertyContainer):
                         ArkSaveLogger.parser_log(f"Properties offset: {self.properties_offset}")
                         binary_reader.validate_uint32(0)
 
-                if not from_custom_bytes: 
+                if not from_custom_bytes:
+                    ArkSaveLogger.parser_log(f"Reading properties for object {self.blueprint} ({self.uuid})")
                     self.read_properties(binary_reader, self.parser_type, binary_reader.size())
                     
                     if  binary_reader.size() - binary_reader.position >= 20:
@@ -111,7 +119,9 @@ class ArkGameObject(ArkPropertyContainer):
                             raise Exception("Unknown data left")
                         
                 if no_header:
-                    self.blueprint = self.get_property_value("ItemArchetype").value
+                    bp_ref = self.get_property_value("ItemArchetype", None)
+                    if bp_ref is not None:
+                        self.blueprint = bp_ref.value
             except Exception as e:
                 ArkSaveLogger.error_log(f"Error while reading object {self.blueprint} ({self.uuid}): {e}")
                 ArkSaveLogger.set_file(binary_reader, "debug.bin")
@@ -227,6 +237,33 @@ class ArkGameObject(ArkPropertyContainer):
         buffer.validate_uint32(0)
         return name
     
+    @staticmethod
+    def read_name(obj_uuid: UUID, reader: ArkBinaryParser) -> str:
+        reader.set_position(0)
+        string_name = False
+
+        try:
+            class_name = reader.read_name()
+        except Exception as e:
+            # Check for string name instead of name table reference, this sometimes happens since Lost Colony
+            # To be ivestigated why this happens
+            reader.set_position(0)
+            try:
+                unknow_id = reader.read_uint32()
+                reader.validate_uint64(0)
+                reader.validate_uint32(1)
+                class_name = reader.read_string()
+                # reader.validate_uint32(0)
+                string_name = True
+                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
+    
     def get_short_name(self) -> str:
         to_strip_end = [
             "_C",
@@ -262,4 +299,7 @@ class ArkGameObject(ArkPropertyContainer):
             if short.startswith(strip):
                 short = short[len(strip):]
 
-        return short
+        return short
+    
+    def __str__(self):
+            return f"ArkGameObject(UUID: {self.uuid}, Blueprint: {self.blueprint}, Location: {self.location}, Properties: {len(self.properties)} properties)"

arkparse-0.4.1/src/arkparse/object_model/cluster_data/ark_cluster_data.py

@@ -0,0 +1,52 @@
+from pathlib import Path
+
+from arkparse.object_model.ark_game_object import ArkGameObject
+from arkparse.object_model.cluster_data.cluster_data_item import ClusterDataItem
+from arkparse.parsing.ark_archive import ArkArchive
+from arkparse.object_model.cluster_data.cluster_data_dino import ClusterDataDino
+
+class ClusterData:
+    def __init__(self, path: Path, uuid: str):
+        self._path = path
+        self._uuid = uuid
+        self._archive_object: ArkArchive = self._parse()
+        self._ark_data = self._archive_object.get_object_by_class("/Script/ShooterGame.ArkCloudInventoryData")
+        if self._ark_data is None:
+            self._ark_data = self._archive_object.get_object_by_class("/Script/ShooterGame.PrimalLocalProfile")
+            self._ark_data = self._ark_data.get_property_value("MyArkData", None)
+        self._ark_data_items: list[ArkGameObject] = self._ark_data.get_property_value("ArkItems", [])
+        self._uploaded_dinos: list[ArkGameObject] = self._ark_data.get_property_value("ArkTamedDinosData", [])
+
+        self.dinos: list[ClusterDataDino] = []
+        self.items: list[ClusterDataItem] = []
+
+        for item in self._ark_data_items:
+            item = ClusterDataItem(item, len(self._ark_data_items))
+            self.items.append(item)
+
+        for dino in self._uploaded_dinos:
+            dino_data = ClusterDataDino(dino, len(self.dinos))
+            self.dinos.append(dino_data)
+
+    def _check_exists(self):
+        path_exists = self._path.exists()
+
+        if not path_exists:
+            raise FileNotFoundError(f"Cluster data folder not found at path: {self._path}")
+
+        file_path = self._path / f"{self._uuid}"
+        file_exists = file_path.exists()
+
+        if not file_exists:
+            raise FileNotFoundError(f"Cluster data file not found in folder: {file_path}")
+        
+    def _parse(self) -> ArkArchive:
+        self._check_exists()
+
+        file_path = self._path / f"{self._uuid}"
+        with open(file_path, "rb") as f:
+            data = f.read()
+
+        return ArkArchive(data, from_store=False)
+
+    

arkparse-0.4.1/src/arkparse/object_model/cluster_data/cluster_data_dino.py

@@ -0,0 +1,63 @@
+from arkparse.object_model.dinos.tamed_dino import TamedDino
+from arkparse.parsing.ark_property_container import ArkPropertyContainer
+from arkparse.parsing.ark_archive import ArkArchive
+from arkparse.classes import Dinos
+
+class ClusterDataDino:
+
+    def __init__(self, cluster_dino_data: ArkPropertyContainer, dino_index: int):
+        self._data = cluster_dino_data
+        self._dino_index = dino_index
+        self._actual_dino_data = bytes(cluster_dino_data.get_property_value("DinoData"))
+        self._dino_obj = None
+        self._status_obj = None
+        self._ai_controller_obj = None
+        self._inv_obj = None
+        self.version = cluster_dino_data.get_property_value("Version")
+        self.upload_time = cluster_dino_data.get_property_value("UploadTime")
+
+        if self.version != 7:
+            raise ValueError(f"Unsupported cluster dino data version: {self.version} for dino index {dino_index}")
+
+        # temp write binary
+        self._archive = ArkArchive(self._actual_dino_data, from_store=False, cluster_dino=True)
+        for obj in self._archive.objects:
+            # print(obj.class_name)
+            if obj.class_name in Dinos.all_bps:
+                # print(f"Found dino archetype: {obj.class_name}")
+                self._dino_obj = obj
+            if "CharacterStatusComponent" in obj.class_name:
+                # print(f"Found status component: {obj.class_name}")
+                self._status_obj = obj
+            if "AIController" in obj.class_name:
+                # print(f"Found AI controller: {obj.class_name}")
+                self._ai_controller_obj = obj
+            if "InventoryComponent" in obj.class_name:
+                # print(f"Found inventory component: {obj.class_name}")
+                self._inv_obj = obj
+
+        if self._dino_obj is None:
+            raise ValueError(f"Could not find dino archetype in cluster dino data for dino index {dino_index}")
+        
+        if self._status_obj is None:
+            raise ValueError(f"Could not find status component in cluster dino data for dino index {dino_index}")
+        
+        self.dino = TamedDino.from_object(self._dino_obj, self._status_obj)
+        if self._ai_controller_obj:
+            self.dino.ai_controller = self._ai_controller_obj
+        if self._inv_obj:
+            self.dino._inventory = self._inv_obj
+            self.dino.inv_uuid = self._inv_obj.uuid
+
+        # print(self.dino)
+
+    def __str__(self):
+        return f"ClusterDataDino(dino={self.dino})"
+
+    def to_json_obj(self):
+        return {
+            "Version": self.version,
+            "UploadTime": self.upload_time,
+            "Dino": self.dino.to_json_obj()
+        }
+

arkparse-0.4.1/src/arkparse/object_model/cluster_data/cluster_data_item.py

@@ -0,0 +1,67 @@
+from enum import Enum
+
+from arkparse.object_model.ark_game_object import ArkGameObject
+from arkparse.object_model.misc.inventory_item import InventoryItem
+from arkparse.parsing.ark_property_container import ArkPropertyContainer
+from arkparse.api.equipment_api import EquipmentApi
+from arkparse.api.dino_api import DinoApi
+from arkparse.object_model.cryopods.cryopod import Cryopod
+from arkparse.logging import ArkSaveLogger
+
+class ClusterDataItemType(Enum):
+    DINO = "Dino"
+    EQUIPMENT = "Equipment"
+    OTHER = "Other"
+
+class ClusterDataItem:
+    def __init__(self, cluster_item_data: ArkPropertyContainer, item_index: int):
+        self._data = cluster_item_data
+        self.version = cluster_item_data.get_property_value("Version")
+        self.upload_time = cluster_item_data.get_property_value("UploadTime")
+        self.item_type: ClusterDataItemType = None
+        self.item: ArkGameObject = None
+
+        if self.version != 7:
+            raise ValueError(f"Unsupported cluster item data version: {self.version} for item index {item_index}")
+
+        bp = cluster_item_data.get_property_value("ItemArchetype").value.split(' ')[1]
+        ArkSaveLogger.objects_log(f"Item found with archetype {bp} and type {self.item_type}. Version: {self.version}. Upload time: {self.upload_time}.")
+
+        # if "PrimalItem_SCSCryopod" in bp:
+        #     print(cluster_item_data.to_string())
+        #     input("Found cryopod item, press enter to continue...")
+
+        if DinoApi.is_applicable_bp(bp) and (len(cluster_item_data.get_property_value("CustomItemDatas", [])) > 0):
+            ArkSaveLogger.objects_log(f"Parsed as dino item with archetype: {bp}")
+            self.item_type = ClusterDataItemType.DINO
+            obj = ArkGameObject()
+            obj.properties = cluster_item_data.properties
+            self.item = Cryopod.from_object(obj, blueprint=bp)
+        elif EquipmentApi.is_applicable_bp(bp):
+            ArkSaveLogger.objects_log(f"Parsed as equipment item with archetype: {bp}")
+            self.item_type = ClusterDataItemType.EQUIPMENT
+            obj = ArkGameObject()
+            obj.properties = cluster_item_data.properties
+            self.item = EquipmentApi.bp_to_class(bp).from_object(obj)
+        else:
+            ArkSaveLogger.objects_log(f"Parsed as other item with archetype: {bp}")
+            self.item_type = ClusterDataItemType.OTHER
+            obj = ArkGameObject()
+            obj.properties = cluster_item_data.properties
+            self.item: InventoryItem = InventoryItem.from_object(obj)
+            if self.item.quantity == 0:
+                self.item.quantity = 1
+        self.item.object.blueprint = bp
+
+    def __str__(self):
+        return f"ClusterDataItem(type={self.item_type}, item={self.item})"
+        
+        
+    def to_json_obj(self):
+        return {
+            "Version": self.version,
+            "UploadTime": self.upload_time,
+            "Item": self.item.to_json_obj(),
+            "blueprint": self.item.object.blueprint
+        }
+