arkparse 0.2.2__tar.gz → 0.2.3__tar.gz

{arkparse-0.2.2 → arkparse-0.2.3}/.gitignore

@@ -85,6 +85,7 @@ ipython_config.py
 
 **/binary-reader/**
 src/binary_reader/
+tests/temp**
 
 # pyenv
 #   For a library or package, you might want to ignore these files since the code is

{arkparse-0.2.2 → arkparse-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparse
-Version: 0.2.2
+Version: 0.2.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.2.2 → arkparse-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arkparse"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
     "pytz>=2025.2",
     "rcon>=2.4.9",

{arkparse-0.2.2 → arkparse-0.2.3}/src/arkparse/api/base_api.py

@@ -15,6 +15,7 @@ from arkparse.parsing.struct import ActorTransform
 from arkparse.parsing import ArkBinaryParser
 from arkparse.object_model import ArkGameObject
 from arkparse.utils import ImportFile
+from arkparse.logging import ArkSaveLogger
 
 class BaseApi(StructureApi):
     def __init__(self, save, map: ArkMap):
@@ -33,8 +34,8 @@ class BaseApi(StructureApi):
                 closest_dist = dist
 
         return closest
-
-    def get_base_at(self, coords: MapCoords, radius: float = 0.3, owner_tribe_id = None) -> Base:
+    
+    def get_base_at(self, coords: MapCoords, radius: float = 0.3, owner_tribe_id = None, keystone: Structure = None) -> Base:
         structures = self.get_at_location(self.map, coords, radius)
         if structures is None or len(structures) == 0:
             return None
@@ -50,10 +51,9 @@ class BaseApi(StructureApi):
         if owner_tribe_id is not None:
             all_structures = {k: v for k, v in all_structures.items() if v.owner.tribe_id == owner_tribe_id}
 
-        keystone = self.__get_closest_to(all_structures, coords)
-
+        if keystone is None:
+            keystone = self.__get_closest_to(all_structures, coords)
         keystone_owner = keystone.owner if keystone is not None else None
-
         filtered_structures = {k: v for k, v in all_structures.items() if v.owner == keystone_owner}
 
         return Base(keystone.object.uuid, filtered_structures) if keystone is not None else None
@@ -168,6 +168,30 @@ class BaseApi(StructureApi):
             base.move_to(location, self.save)
 
         return base
+    
+    def get_all_bases(self, only_connected: bool = False, radius: float = 0.3) -> List[Base]:
+        all_bases: List[Base] = []
+        all_structures: Dict[UUID, Structure] = super().get_all()
+        visited_structures: List[UUID] = []
+
+        for key, structure in all_structures.items():
+            base = None
+            if key in visited_structures:
+                continue
+    
+            if only_connected:
+                connected = self.get_connected_structures({key: structure})
+                base = Base(structure.uuid, connected)
+                all_bases.append(base)
+            else:
+                base = self.get_base_at(structure.location.as_map_coords(self.map), radius, structure.owner.tribe_id, structure)
+
+            for structure in base.structures.values():
+                visited_structures.append(structure.uuid)
+
+            ArkSaveLogger.api_log(f"Parsed base at {"Unknown" if base.location is None else base.keystone.location.as_map_coords(self.map)} with {len(base.structures)} structures, owner: {base.owner}")
+
+        return all_bases
 
                 
 

{arkparse-0.2.2 → arkparse-0.2.3}/src/arkparse/api/dino_api.py

@@ -131,7 +131,7 @@ class DinoApi:
                                 continue
                             ArkSaveLogger.set_log_level(ArkSaveLogger.LogTypes.PARSER, True)
                             parser = ArkBinaryParser(self.save.get_game_obj_binary(obj.uuid), self.save.save_context)
-                            cryopod = Cryopod(obj.uuid, parser)
+                            cryopod = Cryopod(obj.uuid, save=self.save)
                             ArkSaveLogger.set_log_level(ArkSaveLogger.LogTypes.PARSER, False)
                             ArkSaveLogger.error_log(f"Error parsing cryopod {obj.uuid}: {e}")
 
@@ -391,15 +391,15 @@ class DinoApi:
         return np.array(heatmap)
     
     
-    def get_best_dino_for_stat(self, classes: List[str] = None, stat: ArkStat = None, only_tamed: bool = False, only_untamed: bool = False, base_stat: bool = False, mutated_stat=False) -> (Dino, int, ArkStat):
+    def get_best_dino_for_stat(self, classes: List[str] = None, stat: ArkStat = None, only_tamed: bool = False, only_untamed: bool = False, base_stat: bool = False, mutated_stat=False, level_upper_bound=None) -> (Dino, int, ArkStat):
         if only_tamed and only_untamed:
             raise ValueError("Cannot specify both only_tamed and only_untamed")
         
         if mutated_stat and base_stat:
             raise ValueError("Cannot specify both base_stat and base_mutated_stat")
         
-        if classes is not None:
-            dinos = self.get_all_filtered(class_names=classes, include_cryopodded=True)
+        if classes is not None or level_upper_bound is not None:
+            dinos = self.get_all_filtered(class_names=classes, include_cryopodded=True, level_upper_bound=level_upper_bound)
         else:
             dinos = self.get_all()
 
@@ -450,8 +450,8 @@ class DinoApi:
                 if file_path.name.endswith(".bin") or file_path.name.startswith("loc_"):
                     out.append(ImportFile(str(file_path)))
         return out
-    
-    def import_dino(self, path: Path, location: ActorTransform = None) -> Dino:
+
+    def import_dino(self, path: Path, location: ActorTransform = None) -> Dino | TamedDino:
         uuid_translation_map = {}
 
         def replace_uuids(uuid_map: Dict[UUID, UUID], bytes_: bytes):
@@ -494,6 +494,7 @@ class DinoApi:
                 ArkSaveLogger.api_log(f"Added inventory item {item.uuid} to DB")
 
         # Get inventory and add to DB
+        inventory = None
         for file in files:
             if file.type == "inv":
                 new_uuid = uuid_translation_map[file.uuid]
@@ -515,8 +516,6 @@ class DinoApi:
                 self.save.add_obj_to_db(new_uuid, parser.byte_buffer)
                 stats = DinoStats(uuid=new_uuid, save=self.save)
                 stats.reidentify(new_uuid)
-                stats.binary.replace_boolean(stats.object.find_property("bServerFirstInitialized"), False)
-                self.save.modify_game_obj(stats.object.uuid, stats.binary.byte_buffer)
                 ArkSaveLogger.api_log(f"Added dino stats {stats.uuid} to DB")
 
         # Get AI controller and add to DB
@@ -546,16 +545,16 @@ class DinoApi:
                 if location is not None:
                     dino.set_location(location)
 
-                dino.binary.replace_boolean(dino.object.find_property("bServerInitializedDino"), False)
-                # dino.binary.replace_boolean(dino.object.find_property("bSavedWhenStasised"), False)
-                # dino.binary.replace_u32(dino.object.find_property("TamingTeamID"), 1466169314)
-                # dino.binary.replace_u32(dino.object.find_property("TargetingTeam"), 1466169314)
-                # dino.binary.replace_u32(dino.object.find_property("OwningPlayerID"), 290175622)
-                dino.update_binary()
-
                 ArkSaveLogger.api_log(f"Replacing name \"{dino.stats.object.names[1]}\" with \"{dino.object.names[0]}\"")
                 dino.stats.replace_name_at_index_with(1, dino.object.names[0])
                 dino.stats.update_binary()
+                
+                if inventory is not None:
+                    ArkSaveLogger.api_log(f"Replacing inventory name \"{inventory.object.names[1]}\" with \"{dino.object.names[0]}\"")
+                    inventory.replace_name_at_index_with(1, dino.object.names[0])
+                    inventory.update_binary()
+                    dino: TamedDino = TamedDino(uuid=new_uuid, save=self.save)
+                    return dino
 
                 return dino
 

{arkparse-0.2.2 → arkparse-0.2.3}/src/arkparse/api/player_api.py

@@ -125,7 +125,7 @@ class PlayerApi:
         OBJECT = 0
         DINO = 1
 
-    def __init__(self, save: AsaSave, ignore_error: bool = False):
+    def __init__(self, save: AsaSave, ignore_error: bool = False, no_pawns: bool = False):
         self.players: List[ArkPlayer] = []
         self.tribes: List[ArkTribe] = []
         self.tribe_to_player_map: Dict[int, List[ArkPlayer]] = {}
@@ -141,7 +141,7 @@ class PlayerApi:
             ArkSaveLogger.api_log("Profile data not found in save, checking database")
             self.from_store = False
 
-        if self.save is not None:
+        if self.save is not None and not no_pawns:
             ArkSaveLogger.api_log(f"Retrieving player pawns")
             self.__init_pawns()
 
@@ -326,6 +326,12 @@ class PlayerApi:
                 dict[p.id_] = p.stats.experience
 
         return self.__calc_stat(xp, stat_type) if not as_dict else dict
+
+    def get_tribe(self, tribe_id: int):
+        for t in self.tribes:
+            if t.tribe_id == tribe_id:
+                return t
+        return None
     
     def get_player_with(self, stat: int, stat_type: int = StatType.HIGHEST):
         istat = self.__get_stat(stat)

{arkparse-0.2.2 → arkparse-0.2.3}/src/arkparse/api/structure_api.py

@@ -2,7 +2,7 @@ from typing import Dict, Union, List
 from uuid import UUID
 
 from arkparse.saves.asa_save import AsaSave
-from arkparse.parsing import GameObjectReaderConfiguration, ArkBinaryParser
+from arkparse.parsing import GameObjectReaderConfiguration
 from arkparse.ftp.ark_ftp_client import ArkFtpClient
 from arkparse.utils import TEMP_FILES_DIR
 
@@ -11,6 +11,7 @@ from arkparse.object_model.misc.object_owner import ObjectOwner
 from arkparse.object_model.structures import Structure, StructureWithInventory
 from arkparse.parsing.struct.actor_transform import MapCoords
 from arkparse.enums.ark_map import ArkMap
+from arkparse.logging import ArkSaveLogger
 
 class StructureApi:
     def __init__(self, save: AsaSave):
@@ -21,52 +22,42 @@ class StructureApi:
     def get_all_objects(self, config: GameObjectReaderConfiguration = None) -> Dict[UUID, ArkGameObject]:
         if config is None:
             reader_config = GameObjectReaderConfiguration(
-                blueprint_name_filter=lambda name: name is not None and "/Structures" in name and not "PrimalItemStructure_" in name
+                blueprint_name_filter=lambda name: name is not None \
+                                                   and "/Structures" in name \
+                                                   and not "PrimalItemStructure_" in name \
+                                                   and not "/Skins/" in name \
+                                                   and not "PrimalInventory" in name \
+                                                   and not "Tileset" in name \
+                                                   and not "PrimalItemStructureSkin" in name
+                                                   and not "PrimalItemResource" in name \
+                                                   and not "/TrainCarts/" in name \
             )
         else:
             reader_config = config
 
         objects = self.save.get_game_objects(reader_config)
 
-        # for key, obj in objects.items():
-        #     print(obj.blueprint)
-
         return objects
-    
-    def _parse_single_structure(self, obj: ArkGameObject) -> Union[Structure, StructureWithInventory]:
+
+    def _parse_single_structure(self, obj: ArkGameObject, bypass_inventory: bool = True) -> Union[Structure, StructureWithInventory]:
         if obj.uuid in self.parsed_structures.keys():
             return self.parsed_structures[obj.uuid]
         
         if obj.get_property_value("MaxItemCount") is not None or (obj.get_property_value("MyInventoryComponent") is not None and obj.get_property_value("CurrentItemCount") is not None):
-            structure = StructureWithInventory(obj.uuid, self.save)
-        else:
-            structure = Structure(obj.uuid, self.save)
-
-        for key, loc in self.save.save_context.actor_transforms.items():
-            if key == obj.uuid:
-                structure.set_actor_transform(loc)
-                break
-
-        self.parsed_structures[obj.uuid] = structure
-
-        return structure
-
-    def _parse_single_structure_fast(self, obj: ArkGameObject, parser: ArkBinaryParser = None) -> Union[Structure | StructureWithInventory]:
-        """Same as _parse_single_structure, but does not parse Inventory and does not store in cache."""
-
-        if obj.get_property_value("MaxItemCount") is not None or (obj.get_property_value("MyInventoryComponent") is not None and obj.get_property_value("CurrentItemCount") is not None):
-            structure = StructureWithInventory(obj.uuid, self.save, bypass_inventory=True)
+            structure = StructureWithInventory(obj.uuid, self.save, bypass_inventory=bypass_inventory)
         else:
             structure = Structure(obj.uuid, self.save)
 
         if obj.uuid in self.save.save_context.actor_transforms:
             structure.set_actor_transform(self.save.save_context.actor_transforms[obj.uuid])
 
+        self.parsed_structures[obj.uuid] = structure
+
         return structure
 
-    def get_all(self, config: GameObjectReaderConfiguration = None) -> Dict[UUID, Union[Structure, StructureWithInventory]]:
+    def get_all(self, config: GameObjectReaderConfiguration = None, bypass_inventory: bool = True) -> Dict[UUID, Union[Structure, StructureWithInventory]]:
 
-        if self.retrieved_all:
+        if self.retrieved_all and config is None:
             return self.parsed_structures
         
         objects = self.get_all_objects(config)
@@ -78,8 +69,12 @@ class StructureApi:
             if obj is None:
                 print(f"Object is None for {key}")
                 continue
+
+            if obj.get_property_value("StructureID") is None:
+                ArkSaveLogger.warning_log(f"Object {obj.uuid} ({obj.blueprint}) is not a structure, skipping")
+                continue
             
-            structure = self._parse_single_structure(obj)
+            structure = self._parse_single_structure(obj, bypass_inventory)
 
             structures[obj.uuid] = structure
 
@@ -88,23 +83,10 @@ class StructureApi:
 
         return structures
 
-    def get_all_fast(self, config: GameObjectReaderConfiguration = None) -> List[Structure | StructureWithInventory]:
-        """Same as get_all, but uses fast parsing and does not store in cache."""
-
-        objects = self.get_all_objects(config)
-
-        structures = []
-
-        for obj in objects.values():
-            if obj is None:
-                continue
-            structure = self._parse_single_structure_fast(obj)
-            structures.append(structure)
-
-        return structures
-
     def get_by_id(self, id: UUID) -> Union[Structure, StructureWithInventory]:
         obj = self.save.get_game_object_by_id(id)
+        if obj is None:
+            return None
         return self._parse_single_structure(obj)
     
     def get_at_location(self, map: ArkMap, coords: MapCoords, radius: float = 0.3, classes: List[str] = None) -> Dict[UUID, Union[Structure, StructureWithInventory]]:
@@ -158,11 +140,16 @@ class StructureApi:
             blueprint_name_filter=lambda name: name in blueprints
         )
 
+        ArkSaveLogger.api_log(f"Getting structures by class filter: {blueprints}")
+
         structures = self.get_all(config)
 
         for key, obj in structures.items():
             result[key] = obj
 
+        # for key, obj in structures.items():
+        #     print(obj.blueprint)
+
         return result
     
     def filter_by_owner(self, structures: Dict[UUID, Union[Structure, StructureWithInventory]], owner: ObjectOwner = None, owner_tribe_id: int = None, invert: bool = False) -> Dict[UUID, Union[Structure, StructureWithInventory]]:
@@ -193,16 +180,21 @@ class StructureApi:
     def get_connected_structures(self, structures: Dict[UUID, Union[Structure, StructureWithInventory]]) -> Dict[UUID, Union[Structure, StructureWithInventory]]:
         result = structures.copy()
         new_found = True
+        ignore = []
 
         while new_found:
             new_found = False
             new_result = result.copy()
-            for key, s in result.items():
+            for _, s in result.items():
                 for uuid in s.linked_structure_uuids:
-                    if uuid not in new_result.keys():
+                    if uuid not in new_result.keys() and uuid not in ignore:
                         new_found = True
                         obj = self.get_by_id(uuid)
-                        new_result[uuid] = obj
+                        if obj is not None:
+                            new_result[uuid] = obj
+                        else:
+                            ignore.append(uuid)
+                            ArkSaveLogger.api_log(f"Could not find linked structure {uuid}, ignoring")
             result = new_result
 
         return result

{arkparse-0.2.2 → arkparse-0.2.3}/src/arkparse/classes/dinos.py

@@ -58,7 +58,12 @@ class Abberant:
            equus, manta, araneo, electrophorus, moschops, diplodocus, megalania, 
            ovis, paraceratherium, sarco, dimorphodon, fasolasuchus, gigantoraptor, 
            trilobite, sabertooth_salmon, meganeura]
-    
+
+class PaleoAlphas:
+    alpha_rex = "/PA_EVO_Pack_01/Dinos/EVO_Rex/Alpha/EVO_Alpha_Rex_Character_BP.EVO_Alpha_Rex_Character_BP_C"
+
+    all_bps = [alpha_rex]
+
 class Alphas:
     alpha_reaper_king = "/Game/Aberration/Dinos/Nameless/MegaXenomorph_Character_BP_Male_Surface.MegaXenomorph_Character_BP_Male_Surface_C"
     alpha_karkinos = "/Game/Aberration/Dinos/Crab/MegaCrab_Character_BP.MegaCrab_Character_BP_C"
@@ -71,12 +76,15 @@ class Alphas:
     alpha_rex = "/Game/PrimalEarth/Dinos/Rex/MegaRex_Character_BP.MegaRex_Character_BP_C"
     alpha_tuso = "/Game/PrimalEarth/Dinos/Tusoteuthis/Mega_Tusoteuthis_Character_BP.Mega_Tusoteuthis_Character_BP_C"
     alpha_leedsichthys = "/Game/PrimalEarth/Dinos/Leedsichthys/Alpha_Leedsichthys_Character_BP.Alpha_Leedsichthys_Character_BP_C"
+    alpha_fire_wyvern = "/Game/ScorchedEarth/Dinos/Wyvern/MegaWyvern_Character_BP_Fire.MegaWyvern_Character_BP_Fire_C"
+
+    paleo = PaleoAlphas()
 
     all_bps = [
         alpha_reaper_king, alpha_karkinos, alpha_basilisk,
         alpha_carnotaurus, alpha_megalodon, alpha_mosasaurus, alpha_raptor, 
-        alpha_deathworm, alpha_rex, alpha_tuso, alpha_leedsichthys
-    ]
+        alpha_deathworm, alpha_rex, alpha_tuso, alpha_leedsichthys, alpha_fire_wyvern
+    ] + paleo.all_bps
 
 class Flyers:
     class Wyverns:
@@ -169,6 +177,12 @@ class Corrupted:
     all_bps = [ arthropluera, carno, chalicotherium, dilo, giganotosaurus,
                 reaper_king, paraceratherium, ptero, raptor, alpha_rex,
                 rex, rock_drake, spino, stego, trike, wyvern ]
+                
+class event:
+    dodo_rex = "/Game/PrimalEarth/Dinos/DodoRex/DodoRex_Character_BP.DodoRex_Character_BP_C"
+    dodo_wyvern = "/Game/ScorchedEarth/Dinos/DodoWyvern/DodoWyvern_Character_BP.DodoWyvern_Character_BP_C"
+    
+    all_bps = [dodo_rex, dodo_wyvern]
 
 class NonTameable:
     lamprey = "/Game/Aberration/Dinos/Lamprey/Lamprey_Character.Lamprey_Character_C"
@@ -199,6 +213,7 @@ class NonTameable:
     yeti = "/Game/PrimalEarth/Dinos/Bigfoot/Yeti_Character_BP.Yeti_Character_BP_C"
     corrupted = Corrupted()
     alpha = Alphas()
+    event = event()
 
     all_bps = [
         lamprey, lightbug, meganeura, surface_reaper, surface_nameless
@@ -207,7 +222,31 @@ class NonTameable:
         sabertooth_salmon, trilobite, death_worm, jugbug_oil, jugbug_water,
         enforcer, scout, defence_unit, polar_bear, iceworm, tek_giga,
         leedsichthys, yeti
-    ] + corrupted.all_bps + alpha.all_bps
+    ] + corrupted.all_bps + alpha.all_bps + event.all_bps
+
+class Paleo:
+    yuti = "/PA_Ascension/Dinos/GreaterYuty/Paleo_Yutyrannus_Character_BP.Paleo_Yutyrannus_Character_BP_C"
+    fasola = "/PA_Ascension/Dinos/PaleoFasola/Paleo_Fasola_Character_BP.Paleo_Fasola_Character_BP_C"
+    gigantoraptor = "/PA_Ascension/Dinos/PaleoGigantoraptor/Paleo_Gigantoraptor_Character_BP.Paleo_Gigantoraptor_Character_BP_C"
+    kentro = "/PA_Ascension/Dinos/PaleoKentro/Paleo_Kentro_Character_BP.Paleo_Kentro_Character_BP_C"
+    megalosaur = "/PA_Ascension/Dinos/PaleoMegalosaur/Paleo_Megalosaurus_Character_BP.Paleo_Megalosaurus_Character_BP_C"
+    moschops = "/PA_Ascension/Dinos/PaleoMoschops/Paleo_Moschops_Character_BP.Paleo_Moschops_Character_BP_C"
+    purlovia = "/PA_Ascension/Dinos/PaleoPurlovia/Paleo_Purlovia_Character_BP.Paleo_Purlovia_Character_BP_C"
+    raptor = "/PA_Ascension/Dinos/PaleoRaptor/Paleo_Raptor_Character_BP.Paleo_Raptor_Character_BP_C"
+    sarco = "/PA_Ascension/Dinos/PaleoSarco/Paleo_Sarco_Character_BP.Paleo_Sarco_Character_BP_C"
+    spino = "/PA_Ascension/Dinos/PaleoSpino/Paleo_Spino_Character_BP.Paleo_Spino_Character_BP_C"
+    stego = "/PA_Ascension/Dinos/PaleoStego/Paleo_Stego_Character_BP.Paleo_Stego_Character_BP_C"
+    thyla = "/PA_Ascension/Dinos/PaleoThyla/Paleo_Thylacoleo_Character_BP.Paleo_Thylacoleo_Character_BP_C"
+    trike = "/PA_Ascension/Dinos/PaleoTrike/Paleo_Trike_Character_BP.Paleo_Trike_Character_BP_C"
+    giga = "/PA_EVO_Pack_01/Dinos/EVO_Giga/EVO_Giga_Character_BP.EVO_Giga_Character_BP_C"
+    rex = "/PA_EVO_Pack_01/Dinos/EVO_Rex/EVO_Rex_Character_BP.EVO_Rex_Character_BP_C"
+    legacy_rex = "/PA_EVO_Pack_01/Dinos/EVO_Rex/Legacy/EVO_Legacy_Rex_Character_BP.EVO_Legacy_Rex_Character_BP_C"
+    rex = "/PA_EVO_Pack_01/Dinos/EVO_Rex/Paleo/EVO_Paleo_Rex_Character_BP.EVO_Paleo_Rex_Character_BP_C"
+    mosa = "/PA_EVO_Pack_02/Dinos/EVO_Mosa/Paleo/EVO_Paleo_Mosa_Character_BP.EVO_Paleo_Mosa_Character_BP_C"
+
+    all_bps = [yuti, fasola, gigantoraptor, kentro, megalosaur, moschops,
+               purlovia, raptor, sarco, spino, stego, thyla, trike,
+               giga, rex, legacy_rex, rex, mosa]
 
 class Dinos:
     # Aberrant Dinos
@@ -219,7 +258,7 @@ class Dinos:
     cosmo = "/Game/Packs/Steampunk/Dinos/JumpingSpider/JumpingSpider_Character_BP.JumpingSpider_Character_BP_C"
     karkinos = "/Game/Aberration/Dinos/Crab/Crab_Character_BP.Crab_Character_BP_C"
     yi_ling = "/Game/ASA/Dinos/YiLing/YiLing_Character_BP.YiLing_Character_BP_C"
-    stegosaurus_duplicate = "/Game/PrimalEarth/Dinos/Stego/Stego_Character_BP.Stego_Character_BP_C"
+    stegosaurus = "/Game/PrimalEarth/Dinos/Stego/Stego_Character_BP.Stego_Character_BP_C"
     giant_bison = "/Game/ASA/Dinos/Bison/Bison_Character_BP.Bison_Character_BP_C"
     ceratosaurus = "/Game/ASA/Dinos/Ceratosaurus/Dinos/Ceratosaurus_Character_BP_ASA.Ceratosaurus_Character_BP_ASA_C"
     deinosuchus = "/Game/ASA/Dinos/Deinosuchus/DeinosuchusASA_Character_BP.DeinosuchusASA_Character_BP_C"
@@ -326,6 +365,7 @@ class Dinos:
     rubble_golem = "/Game/ScorchedEarth/Dinos/RockGolem/RubbleGolem_Character_BP.RubbleGolem_Character_BP_C"
 
     abberant = Abberant()
+    paleo = Paleo()
     flyers = Flyers()
     dlc_dinos = DlcDinos()
     shoulder_pets = ShoulderPets()
@@ -333,7 +373,7 @@ class Dinos:
 
     all_bps = [
         roll_rat, rock_drake, basilisk, ravager, reaper_queen, cosmo,
-        karkinos, yi_ling, stegosaurus_duplicate, giant_bison, ceratosaurus,
+        karkinos, yi_ling, stegosaurus, giant_bison, ceratosaurus,
         deinosuchus, deinotherium, fasolasuchus, gigantoraptor, xiphactinus,
         tamed_reaper_king, achatina, allosaurus, anglerfish, ankylosaurus,
         arthropleura, baryonix, basilosaurus, onyc, castoroides,
@@ -359,4 +399,5 @@ class Dinos:
         velonosaur, yutyrannus, tek_parasaur, queen_bee,
         rubble_golem
     ]  + abberant.all_bps + flyers.all_bps + \
-        dlc_dinos.all_bps + shoulder_pets.all_bps + non_tameable.all_bps
+        dlc_dinos.all_bps + shoulder_pets.all_bps + non_tameable.all_bps + \
+        paleo.all_bps

{arkparse-0.2.2 → arkparse-0.2.3}/src/arkparse/object_model/bases/base.py

@@ -46,6 +46,9 @@ class Base:
         average_z = 0
 
         for _, structure in self.structures.items():
+            if structure.location is None:
+                ArkSaveLogger.warning_log(f"Structure {structure.uuid} has no location: {structure.location}")
+                continue
             average_x += structure.location.x
             average_y += structure.location.y
             average_z += structure.location.z

{arkparse-0.2.2 → arkparse-0.2.3}/src/arkparse/object_model/dinos/dino.py

@@ -22,6 +22,7 @@ class Dino(ParsedObjectBase):
 
     is_female: bool = False
     is_cryopodded: bool = False
+    is_dead: bool = False
 
     ai_controller: DinoAiController = None
 
@@ -38,6 +39,7 @@ class Dino(ParsedObjectBase):
         self.id1 = self.object.get_property_value("DinoID1")
         self.id2 = self.object.get_property_value("DinoID2")
         self.gene_traits = self.object.get_array_property_value("GeneTraits")
+        self.is_dead = self.object.get_property_value("bIsDead", False)
         self.location = ActorTransform(vector=self.object.get_property_value("SavedBaseWorldLocation"))
     
     def __init__(self, uuid: UUID = None, save: AsaSave = None):
@@ -48,8 +50,9 @@ class Dino(ParsedObjectBase):
             self.stats = DinoStats(UUID(stat_uuid), save=save)
 
         if save is not None and self.object.get_property_value("Owner") is not None:
-            ai_uuid = self.object.get_property_value("Owner").value
-            self.ai_controller = DinoAiController(UUID(ai_uuid), save=save)
+            if self.save.is_in_db(UUID(self.object.get_property_value("Owner").value)):
+                ai_uuid = self.object.get_property_value("Owner").value
+                self.ai_controller = DinoAiController(UUID(ai_uuid), save=save)
 
     def __str__(self) -> str:
         return "Dino(type={}, lv={})".format(self.get_short_name(), self.stats.current_level)
@@ -223,7 +226,8 @@ class Dino(ParsedObjectBase):
     def store_binary(self, path, name = None, prefix = "obj_", no_suffix=False):
         loc_name = name if name is not None else str(self.object.uuid)
         self.stats.store_binary(path, name, prefix="status_", no_suffix=no_suffix)
-        self.ai_controller.store_binary(path, name, prefix="ai_", no_suffix=no_suffix)
+        if self.ai_controller is not None:
+            self.ai_controller.store_binary(path, name, prefix="ai_", no_suffix=no_suffix)
         self.location.store_json(path, loc_name)
         return super().store_binary(path, name, prefix=prefix, no_suffix=no_suffix)
 
@@ -241,6 +245,17 @@ class Dino(ParsedObjectBase):
         self.update_binary()
         self.location = location
 
+    def heal(self):
+        self.stats.heal()
+
+    def disable_wandering(self):
+        """
+        Disables the wandering behavior of the dino.
+        """
+        if self.object.has_property("bEnableTamedWandering"):
+            self.binary.replace_boolean(self.object.find_property("bEnableTamedWandering"), False)
+            self.update_binary()
+
     def reidentify(self, new_uuid: UUID = None, update=True):
         new_id_1 = random.randint(0, 2**32 - 1)
         new_id_2 = random.randint(0, 2**32 - 1)

{arkparse-0.2.2 → arkparse-0.2.3}/src/arkparse/object_model/dinos/dino_ai_controller.py

@@ -10,7 +10,7 @@ class DinoAiController(ParsedObjectBase):
     def __init_props__(self):
         super().__init_props__()
 
-        self.targeting_team = self.object.get_property_value("TargetingTeam")
+        self.targeting_team = self.object.get_property_value("TargetingTeam", 0)
     
     def __init__(self, uuid: UUID = None, save: AsaSave = None):
         super().__init__(uuid, save=save)

{arkparse-0.2.2 → arkparse-0.2.3}/src/arkparse/object_model/dinos/stats.py

@@ -56,6 +56,12 @@ class StatPoints:
         return self.health + self.stamina + self.torpidity + self.oxygen + self.food + \
                self.water + self.temperature + self.weight + self.melee_damage + \
                self.movement_speed + self.fortitude + self.crafting_speed + (1 if self.type == "NumberOfLevelUpPointsApplied" else 0)
+    
+    def set_stat(self, stat: ArkStat, value: int):
+        if stat.value not in STAT_POSITION_MAP:
+            raise ValueError(f"Invalid stat: {stat}")
+
+        setattr(self, STAT_POSITION_MAP[stat.value], value)
 
     def __str__(self):
         stats = [
@@ -250,3 +256,58 @@ class DinoStats(ParsedObjectBase):
             self.binary.replace_boolean(prop, False)
 
             self.update_binary()
+
+    def heal(self):
+        prop = self.object.find_property("CurrentStatusValues", ArkStat.HEALTH.value)
+        if prop is not None:
+            # Set health to a hugely high value, effectively healing the dino since it is capped at max health which is not directly retrievable
+            self.binary.replace_float(prop, 999999999999999999999)
+            self.update_binary()
+
+    def set_levels(self, levels: int, stat: ArkStat):
+        prop = self.object.find_property("NumberOfLevelUpPointsApplied", stat.value)
+        if prop is not None:
+            self.binary.replace_byte_property(prop, levels)
+        else:
+            raise ValueError(f"Property 'NumberOfLevelUpPointsApplied' for stat {stat} not found in object {self.object.uuid}")
+
+        self.update_binary()
+
+    def set_tamed_levels(self, levels: int, stat: ArkStat):
+        self.added_stat_points.set_stat(stat, levels)
+
+        prop = self.object.find_property("NumberOfLevelUpPointsAppliedTamed", stat.value)
+        if prop is not None:
+            self.binary.replace_byte_property(prop, levels)
+        else:
+            first_index_before = None
+            first_index_after = None
+            for i in range(stat.value):
+                index = stat.value - i - 1
+                prop = self.object.find_property("NumberOfLevelUpPointsAppliedTamed", index)
+
+                if prop is not None:
+                    first_index_before = index
+                    break
+
+            for i in range(stat.value, 12):
+                index = i
+                prop = self.object.find_property("NumberOfLevelUpPointsAppliedTamed", index)
+
+                if prop is not None:
+                    first_index_after = index
+                    break
+
+            if first_index_before is None and first_index_after is None:
+                raise ValueError(f"Cannot insert if no other stats are present for stat {stat} in object {self.object.uuid}")
+            
+            if first_index_before is not None:
+                prop_before = self.object.find_property("NumberOfLevelUpPointsAppliedTamed", first_index_before)
+                self.binary.insert_byte_property(prop_before.value_position + 1 ,"NumberOfLevelUpPointsAppliedTamed", levels, stat.value)
+            elif first_index_after is not None:
+                prop_after = self.object.find_property("NumberOfLevelUpPointsAppliedTamed", first_index_after)
+                self.binary.insert_byte_property(prop_after.name_position, "NumberOfLevelUpPointsAppliedTamed", levels, stat.value)
+            
+            self.update_object()
+
+        self.update_binary()