arkparser 0.4.4__tar.gz → 0.4.6__tar.gz

{arkparser-0.4.4 → arkparser-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparser
-Version: 0.4.4
+Version: 0.4.6
 Summary: Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files
 Author: Vertyco
 License-Expression: MIT
@@ -212,14 +212,14 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `mut-f`, `mut-m` | legacy | **Ancestor-line totals.** `RandomMutationsFemale` and `RandomMutationsMale`, single integers counting the total number of mutations that occurred down the maternal and paternal ancestry lines respectively. These are *not* per-stat, they share the `-m` token with the per-stat mutation block below but mean a different thing. Kept under the legacy names for ASVExport parity. |
 | `cryo` | legacy | `True` for creatures embedded inside cryopod / soultrap / vivarium / dinoball items in the world save, `False` for actor-in-world tames. `export_tamed` walks `WorldSave.iter_cryopod_creatures()` and emits one ASV_Tamed record per embedded creature in addition to the actor-in-world tames; on busy PvE servers cryopodded tames are the majority of the roster (e.g. 10,277 of 11,054 on a live Ragnarok_WP). Cluster-uploaded tames also surface here (via `export_cluster_uploads`) with `cryo=True`. |
 | `ccc` | legacy | `"{x} {y} {z}"` from `LocationData` |
-| `dinoid` | legacy | string form of `id` |
+| `dinoid` | legacy | string form of the dino id. **ASA**: decimal of the combined 64-bit `id`. **ASE**: the two halves concatenated as signed-int32 decimals (`str(DinoID1) + str(DinoID2)`), matching `ASVExport`. |
 | `isMating` | legacy | `bEnableTamedMating` |
 | `isNeutered` | legacy | `bNeutered` |
 | `isClone` | legacy | `bIsClone` or `bIsCloneDino` |
 | `tamedServer` | legacy | `TamedOnServerName` |
 | `uploadedServer` | legacy | `UploadedFromServerName` |
-| `maturation` | legacy | `str(int(BabyAge * 100))` (string for legacy parity) |
-| `traits` | legacy | `CreatureTraits` (full list of mutation trait class names) |
+| `maturation` | legacy | `str(int(BabyAge * 100))` — integer maturation percent (a baby with no `BabyAge` is `0`, a newborn). Note: legacy emits the full float string (e.g. `"7.5131035"`); arkparser truncates to the integer percent. Semantically equal and the downstream consumer coerces to `int` either way. |
+| `traits` | legacy | `CreatureTraits` as a list of `{"trait": <class>}` objects (matches `ASVExport`'s shape, not a flat string list) |
 | `inventory` | legacy | items from `MyInventoryComponent.InventoryItems`. Each entry carries `itemId`, `qty`, `blueprint`, plus a full snake_case property dump flattened in at the top level (`id`, `rating`, `durability`, `quality`, `damage`, `armor`, `durability_max`, `hypo`, `hyper`, `clip_size`, `weight`, `crafter`, `crafter_tribe`, `skill_bonus`, `loaded_ammo`, `spoils_at`, `spoiled_at`, `c0`..`c5`, `egg_*`, etc). `item_stat_values` is unpacked into the universal 8-slot ARK map (slot 0 `gen_quality`, 1 `armor`, 2 `durability_max`, 3 `damage`, 4 `clip_size`, 5 `hypo`, 6 `weight`, 7 `hyperthermal_insulation`); raw uint16s scaled by the per-blueprint multiplier (which lives in the UE blueprint, not the save). Default / unset values are filtered (no `craft_queue=0`, `skin=-1`, `color_pre_skin=[0]*6`, NaN spoil timers, etc). When the item is a **cryopod / soultrap / vivarium / dinoball** with an embedded creature, the entry is enriched with `dino_id` (combined 64-bit id matching the corresponding `ASV_Tamed` record), `dino_creature` (species / class name), and `dino_name` (`TamedName` if set). Cryopods stored in containers (cryofridges, vaults, dedicated storage) get the same enrichment. |
 | `father_id`, `mother_id` | added | combined dino id from the first `DinoAncestors` entry (`null` when missing) |
 | `father_name`, `mother_name` | added | name strings from the first `DinoAncestors` entry |
@@ -256,7 +256,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 
 | Field | Origin | Source / formula |
 |---|---|---|
-| `id`, `dinoid` | legacy | `(DinoID1 << 32) \| DinoID2` and its string form |
+| `id`, `dinoid` | legacy | `id` = `(DinoID1 << 32) \| DinoID2`. `dinoid` = its string form on **ASA**, or `str(DinoID1) + str(DinoID2)` (signed int32) on **ASE**, matching `ASVExport`. |
 | `creature` | legacy | `GameObject.class_name` |
 | `sex` | legacy | `"Female"` if `bIsFemale` else `"Male"` |
 | `lvl` | legacy | `BaseCharacterLevel` (status) |
@@ -302,7 +302,8 @@ For the richest output, hand `export_players` **both**, assemble a wrapper for e
 | `torp`, `temp` | added | same source, indices legacy never emitted |
 | `active` | legacy | last-active datetime; currently `null` (placeholder for parity) |
 | `ccc` | legacy | `"0 0 0"` (no in-world position from profile/cluster source) |
-| `achievements`, `inventory`, `netAddress` | legacy | reserved arrays/string (currently empty for parity) |
+| `achievements` | legacy | reserved array (currently empty for parity) |
+| `netAddress` | legacy (now populated) | Last client IP ARK persisted (`SavedNetworkAddress` in profile `MyData`). Legacy ASVExport reads the same field (ContentPlayer.cs:157 ASE / :341 ASA). `""` when the profile lacks it (e.g. never-played placeholders). ASA stores a clean IPv4/IPv6 string; some ASE saves store an engine-truncated value (e.g. `"[2001"`) reproduced verbatim, matching legacy. |
 | `steamid`, `dataFile` | legacy | platform net id and `{steamid}.arkprofile` filename |
 | `active` | legacy (now populated) | ISO 8601 datetime of last login, converted from profile `LastLoginTime` or in-world pawn `SavedLastTimeHadController`. Legacy schema reserved the field but the old C# exporter only filled it for in-world pawns; the parser fills it for profiles too. `null` when neither source is present. |
 | `lat`, `lon`, `ccc` | legacy (now populated) | In-world position when the record was built from a `PlayerPawn` GameObject. Records sourced from profile / cluster files keep the legacy `0` / `"0 0 0"` placeholders since profiles carry no world position. |

{arkparser-0.4.4 → arkparser-0.4.6}/README.md

@@ -178,14 +178,14 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `mut-f`, `mut-m` | legacy | **Ancestor-line totals.** `RandomMutationsFemale` and `RandomMutationsMale`, single integers counting the total number of mutations that occurred down the maternal and paternal ancestry lines respectively. These are *not* per-stat, they share the `-m` token with the per-stat mutation block below but mean a different thing. Kept under the legacy names for ASVExport parity. |
 | `cryo` | legacy | `True` for creatures embedded inside cryopod / soultrap / vivarium / dinoball items in the world save, `False` for actor-in-world tames. `export_tamed` walks `WorldSave.iter_cryopod_creatures()` and emits one ASV_Tamed record per embedded creature in addition to the actor-in-world tames; on busy PvE servers cryopodded tames are the majority of the roster (e.g. 10,277 of 11,054 on a live Ragnarok_WP). Cluster-uploaded tames also surface here (via `export_cluster_uploads`) with `cryo=True`. |
 | `ccc` | legacy | `"{x} {y} {z}"` from `LocationData` |
-| `dinoid` | legacy | string form of `id` |
+| `dinoid` | legacy | string form of the dino id. **ASA**: decimal of the combined 64-bit `id`. **ASE**: the two halves concatenated as signed-int32 decimals (`str(DinoID1) + str(DinoID2)`), matching `ASVExport`. |
 | `isMating` | legacy | `bEnableTamedMating` |
 | `isNeutered` | legacy | `bNeutered` |
 | `isClone` | legacy | `bIsClone` or `bIsCloneDino` |
 | `tamedServer` | legacy | `TamedOnServerName` |
 | `uploadedServer` | legacy | `UploadedFromServerName` |
-| `maturation` | legacy | `str(int(BabyAge * 100))` (string for legacy parity) |
-| `traits` | legacy | `CreatureTraits` (full list of mutation trait class names) |
+| `maturation` | legacy | `str(int(BabyAge * 100))` — integer maturation percent (a baby with no `BabyAge` is `0`, a newborn). Note: legacy emits the full float string (e.g. `"7.5131035"`); arkparser truncates to the integer percent. Semantically equal and the downstream consumer coerces to `int` either way. |
+| `traits` | legacy | `CreatureTraits` as a list of `{"trait": <class>}` objects (matches `ASVExport`'s shape, not a flat string list) |
 | `inventory` | legacy | items from `MyInventoryComponent.InventoryItems`. Each entry carries `itemId`, `qty`, `blueprint`, plus a full snake_case property dump flattened in at the top level (`id`, `rating`, `durability`, `quality`, `damage`, `armor`, `durability_max`, `hypo`, `hyper`, `clip_size`, `weight`, `crafter`, `crafter_tribe`, `skill_bonus`, `loaded_ammo`, `spoils_at`, `spoiled_at`, `c0`..`c5`, `egg_*`, etc). `item_stat_values` is unpacked into the universal 8-slot ARK map (slot 0 `gen_quality`, 1 `armor`, 2 `durability_max`, 3 `damage`, 4 `clip_size`, 5 `hypo`, 6 `weight`, 7 `hyperthermal_insulation`); raw uint16s scaled by the per-blueprint multiplier (which lives in the UE blueprint, not the save). Default / unset values are filtered (no `craft_queue=0`, `skin=-1`, `color_pre_skin=[0]*6`, NaN spoil timers, etc). When the item is a **cryopod / soultrap / vivarium / dinoball** with an embedded creature, the entry is enriched with `dino_id` (combined 64-bit id matching the corresponding `ASV_Tamed` record), `dino_creature` (species / class name), and `dino_name` (`TamedName` if set). Cryopods stored in containers (cryofridges, vaults, dedicated storage) get the same enrichment. |
 | `father_id`, `mother_id` | added | combined dino id from the first `DinoAncestors` entry (`null` when missing) |
 | `father_name`, `mother_name` | added | name strings from the first `DinoAncestors` entry |
@@ -222,7 +222,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 
 | Field | Origin | Source / formula |
 |---|---|---|
-| `id`, `dinoid` | legacy | `(DinoID1 << 32) \| DinoID2` and its string form |
+| `id`, `dinoid` | legacy | `id` = `(DinoID1 << 32) \| DinoID2`. `dinoid` = its string form on **ASA**, or `str(DinoID1) + str(DinoID2)` (signed int32) on **ASE**, matching `ASVExport`. |
 | `creature` | legacy | `GameObject.class_name` |
 | `sex` | legacy | `"Female"` if `bIsFemale` else `"Male"` |
 | `lvl` | legacy | `BaseCharacterLevel` (status) |
@@ -268,7 +268,8 @@ For the richest output, hand `export_players` **both**, assemble a wrapper for e
 | `torp`, `temp` | added | same source, indices legacy never emitted |
 | `active` | legacy | last-active datetime; currently `null` (placeholder for parity) |
 | `ccc` | legacy | `"0 0 0"` (no in-world position from profile/cluster source) |
-| `achievements`, `inventory`, `netAddress` | legacy | reserved arrays/string (currently empty for parity) |
+| `achievements` | legacy | reserved array (currently empty for parity) |
+| `netAddress` | legacy (now populated) | Last client IP ARK persisted (`SavedNetworkAddress` in profile `MyData`). Legacy ASVExport reads the same field (ContentPlayer.cs:157 ASE / :341 ASA). `""` when the profile lacks it (e.g. never-played placeholders). ASA stores a clean IPv4/IPv6 string; some ASE saves store an engine-truncated value (e.g. `"[2001"`) reproduced verbatim, matching legacy. |
 | `steamid`, `dataFile` | legacy | platform net id and `{steamid}.arkprofile` filename |
 | `active` | legacy (now populated) | ISO 8601 datetime of last login, converted from profile `LastLoginTime` or in-world pawn `SavedLastTimeHadController`. Legacy schema reserved the field but the old C# exporter only filled it for in-world pawns; the parser fills it for profiles too. `null` when neither source is present. |
 | `lat`, `lon`, `ccc` | legacy (now populated) | In-world position when the record was built from a `PlayerPawn` GameObject. Records sourced from profile / cluster files keep the legacy `0` / `"0 0 0"` placeholders since profiles carry no world position. |

{arkparser-0.4.4 → arkparser-0.4.6}/arkparser/__init__.py

@@ -95,4 +95,4 @@ __all__ = [
     "ArkParseError",
 ]
 
-__version__ = "0.4.4"
+__version__ = "0.4.6"

{arkparser-0.4.4 → arkparser-0.4.6}/arkparser/common/binary_reader.py

@@ -22,7 +22,6 @@ Example:
 from __future__ import annotations
 
 import struct
-import typing as t
 from pathlib import Path
 from uuid import UUID
 

{arkparser-0.4.4 → arkparser-0.4.6}/arkparser/common/map_config.py

@@ -11,7 +11,6 @@ Where x, y are Unreal Engine world coordinates.
 from __future__ import annotations
 
 import logging
-import typing as t
 from dataclasses import dataclass
 from pathlib import Path
 

{arkparser-0.4.4 → arkparser-0.4.6}/arkparser/common/version_detection.py

@@ -19,7 +19,6 @@ World saves (.ark files) have different headers:
 
 from __future__ import annotations
 
-import typing as t
 from enum import Enum
 from pathlib import Path
 

{arkparser-0.4.4 → arkparser-0.4.6}/arkparser/data_models.py

@@ -8,6 +8,7 @@ property data from ARK save files.
 from __future__ import annotations
 
 import logging
+import math
 import typing as t
 from dataclasses import dataclass, field
 
@@ -18,6 +19,21 @@ from .properties.registry import read_properties
 logger = logging.getLogger(__name__)
 
 
+def _finite(value: t.Any, default: float) -> float:
+    """Coerce to a finite float; NaN / inf / non-numeric collapse to ``default``.
+
+    Non-finite floats are invalid JSON tokens that crash strict serializers
+    (``json.dumps(allow_nan=False)``, JS ``JSON.parse``, pydantic). Legacy
+    ASVExport substitutes ``0.0001`` for a NaN item rating (ContentItem.cs:62);
+    other non-finite floats fall back to ``0.0``.
+    """
+    try:
+        result = float(value)
+    except (TypeError, ValueError):
+        return default
+    return result if math.isfinite(result) else default
+
+
 @dataclass
 class DinoStats:
     """Statistics for a creature."""
@@ -201,7 +217,7 @@ class UploadedCreature:
             dino_id1=data.get("DinoID1", 0),
             dino_id2=data.get("DinoID2", 0),
             level=level,
-            experience=data.get("DinoExperiencePoints", 0.0),
+            experience=_finite(data.get("DinoExperiencePoints", 0.0), 0.0),
             stats=stats,
             upload_time=data.get("UploadTime", 0),
             version=data.get("Version", 0.0),
@@ -735,8 +751,8 @@ class UploadedItem:
             item_id2=item_id.get("ItemID2", 0) if isinstance(item_id, dict) else 0,
             quantity=ark_tribute.get("ItemQuantity", 1) or 1,
             quality_index=ark_tribute.get("ItemQualityIndex", 0),
-            durability=ark_tribute.get("ItemDurability", 0.0),
-            rating=ark_tribute.get("ItemRating", 0.0),
+            durability=_finite(ark_tribute.get("ItemDurability", 0.0), 0.0),
+            rating=_finite(ark_tribute.get("ItemRating", 0.0), 0.0001),
             slot_index=ark_tribute.get("SlotIndex", 0),
             is_blueprint=ark_tribute.get("bIsBlueprint", False),
             is_engram=ark_tribute.get("bIsEngram", False),

{arkparser-0.4.4 → arkparser-0.4.6}/arkparser/export.py

@@ -355,6 +355,31 @@ def _combine_dino_id(id1: t.Any, id2: t.Any) -> int:
     return (a << 32) | (b & 0xFFFFFFFF)
 
 
+def _dino_id_str(id1: t.Any, id2: t.Any, is_asa: bool) -> str:
+    """Legacy ``dinoid`` string form (engine-dependent).
+
+    ASA emits the decimal of the combined 64-bit id (legacy
+    ``ContentCreature.cs:224`` ``DinoId = Id.ToString()``). ASE concatenates the
+    two id halves as *signed* int32 decimals (legacy ``ContentCreature.cs:378``
+    ``DinoID1.ToString() + DinoID2.ToString()``, where ``GetPropertyValue<int>``
+    reinterprets each stored uint32 as a signed int). The forms differ, so the
+    engine must be known; passing the wrong flag re-introduces the divergence.
+    """
+    assert isinstance(is_asa, bool), "is_asa must be bool"
+    a, b = _int(id1), _int(id2)
+    if a == 0 and b == 0:
+        return "0"
+    if is_asa:
+        return str((a << 32) | (b & 0xFFFFFFFF))
+    a32 = a & 0xFFFFFFFF
+    b32 = b & 0xFFFFFFFF
+    a32 = a32 - 0x100000000 if a32 & 0x80000000 else a32
+    b32 = b32 - 0x100000000 if b32 & 0x80000000 else b32
+    result = f"{a32}{b32}"
+    assert result, "dinoid string must be non-empty"
+    return result
+
+
 def _colors(obj: t.Any) -> list[int]:
     out = [0] * 6
     getter = getattr(obj, "get_properties_by_name", None)
@@ -1052,7 +1077,10 @@ def _tamed_dict(
     mut_pts = _stat_array(status, "NumberOfMutationsAppliedTamed")
     base_level = _int(_prop(status, "BaseCharacterLevel"), default=1) or 1
     extra_level = _int(_prop(status, "ExtraCharacterLevel"))
-    dino_id = _combine_dino_id(_prop(obj, "DinoID1"), _prop(obj, "DinoID2"))
+    is_asa = bool(getattr(save, "is_asa", False))
+    raw_id1 = _prop(obj, "DinoID1")
+    raw_id2 = _prop(obj, "DinoID2")
+    dino_id = _combine_dino_id(raw_id1, raw_id2)
     # Legacy negates the id of stored (cryo/vivarium) creatures so they don't
     # collide with live tames (ContentTamedCreature.cs:122-126/228-232). The
     # dinoid field stays positive (C# sets DinoId = Id.ToString() before negating).
@@ -1073,7 +1101,10 @@ def _tamed_dict(
     is_female = bool(_prop(obj, "bIsFemale", default=False))
     targeting_team = _int(_prop(obj, "TargetingTeam"))
     baby = bool(_prop(obj, "bIsBaby", default=False))
-    baby_age = _float(_prop(obj, "BabyAge"), default=1.0) if baby else 1.0
+    # A baby with no BabyAge property is a newborn (maturation 0), not an adult.
+    # Legacy reads BabyAge with default 0 (ContentCreature.cs:98). Non-babies
+    # stay at 1.0 -> maturation "100".
+    baby_age = _float(_prop(obj, "BabyAge"), default=0.0) if baby else 1.0
     father_id, father_name = _ancestor_parent(obj, "Male")
     mother_id, mother_name = _ancestor_parent(obj, "Female")
     tribe_name = _str(_prop(obj, "TribeName"))
@@ -1100,7 +1131,7 @@ def _tamed_dict(
         "mut-f": _int(_prop(obj, "RandomMutationsFemale")),
         "mut-m": _int(_prop(obj, "RandomMutationsMale")),
         "cryo": bool(_prop(obj, "IsInCryo", default=False)),
-        "dinoid": str(dino_id),
+        "dinoid": _dino_id_str(raw_id1, raw_id2, is_asa),
         "isMating": bool(_prop(obj, "bEnableTamedMating", default=False)),
         "isNeutered": bool(_prop(obj, "bNeutered", default=False)),
         "isClone": bool(_prop(obj, "bIsClone", default=False))
@@ -1109,7 +1140,9 @@ def _tamed_dict(
         "uploadedServer": _str(_prop(obj, "UploadedFromServerName")),
         "maturation": str(int(baby_age * 100)),
         **_flat_stats(mut_pts, "m"),
-        "traits": _traits(obj),
+        # Legacy emits tamed traits as a list of objects ([{"trait": <class>}]),
+        # not a flat string list (ContentPack.cs:723-735). Match that shape.
+        "traits": [{"trait": tr} for tr in _traits(obj)],
         "inventory": _inventory_items(obj, lookup),
         "father_id": father_id,
         "mother_id": mother_id,
@@ -1615,12 +1648,15 @@ def _wild_dict(
     obj: t.Any,
     status: t.Any,
     map_config: MapConfig | None,
+    is_asa: bool = False,
 ) -> dict[str, t.Any]:
     base_pts = _stat_array(status, "NumberOfLevelUpPointsApplied")
     base_level = _int(_prop(status, "BaseCharacterLevel"), default=1) or 1
     colors = _colors(obj)
     is_female = bool(_prop(obj, "bIsFemale", default=False))
-    dino_id = _combine_dino_id(_prop(obj, "DinoID1"), _prop(obj, "DinoID2"))
+    raw_id1 = _prop(obj, "DinoID1")
+    raw_id2 = _prop(obj, "DinoID2")
+    dino_id = _combine_dino_id(raw_id1, raw_id2)
     traits = _traits(obj)
     class_name = getattr(obj, "class_name", "") or ""
     tameable = _is_tameable(class_name, obj)
@@ -1632,7 +1668,7 @@ def _wild_dict(
         "lvl": base_level,
         **_flat_stats(base_pts),
         **{f"c{i}": colors[i] for i in range(6)},
-        "dinoid": str(dino_id),
+        "dinoid": _dino_id_str(raw_id1, raw_id2, is_asa),
         "tameable": tameable,
         # Legacy emits the first trait as a singular ``trait``; the full
         # CreatureTraits list is exposed alongside as ``traits``.
@@ -1647,8 +1683,9 @@ def _wild_dict(
 
 def export_wild(save: t.Any, map_config: MapConfig | None = None) -> list[dict[str, t.Any]]:
     objects = _world_objects(save, "get_wild_creatures", "wild_objects")
+    is_asa = bool(getattr(save, "is_asa", False))
     lookup = _save_lookup(save)
-    return [_wild_dict(obj, _status_for(obj, lookup), map_config) for obj in objects]
+    return [_wild_dict(obj, _status_for(obj, lookup), map_config, is_asa) for obj in objects]
 
 
 def _player_from_profile(
@@ -1684,7 +1721,7 @@ def _player_from_profile(
         "ccc": "0 0 0",
         "achievements": [],
         "inventory": [],
-        "netAddress": "",
+        "netAddress": _str(profile.last_net_address),
         "engram_points": profile.total_engram_points,
         "experience": _int(profile.experience),
         "current_stats": _current_stats_dict(status),
@@ -2210,7 +2247,10 @@ def _structure_dict(
         "struct": class_name,
         "name": box_name,
         "locked": locked,
-        "created": _structure_created(obj, save),
+        # Legacy CreatedDateTime is DateTime? -> a null interpolates to "" in
+        # the JSON, never JSON null. Match that (avoids a null-vs-string flip
+        # for structures whose creation time can't be resolved).
+        "created": _structure_created(obj, save) or "",
         "inventory": _inventory_items(obj, lookup),
         "decay_reset": bool(_prop(obj, "bHasResetDecayTime", default=False)),
         "last_ally_in_range": (

{arkparser-0.4.4 → arkparser-0.4.6}/arkparser/files/profile.py

@@ -207,6 +207,25 @@ class Profile(ArkFile):
         except (TypeError, ValueError):
             return None
 
+    @property
+    def last_net_address(self) -> str | None:
+        """Last client IP / network address ARK persisted for this player.
+
+        Read from ``SavedNetworkAddress`` on the profile's ``MyData`` struct
+        (same level as ``LastLoginTime``). Legacy ASVExport reads this exact
+        field (ContentPlayer.cs:157 ASE / :341 ASA) and emits it as the
+        ``netAddress`` player key. Returns ``None`` when the field is absent
+        (e.g. empty placeholder profiles that were never played).
+
+        ASA stores a clean IPv4/IPv6 string; some ASE saves store an
+        engine-truncated value (e.g. ``"[2001"``) which is reproduced
+        verbatim - matching what legacy ASVExport emits for the same save.
+        """
+        val = self._player_data.get("SavedNetworkAddress")
+        if val is None:
+            return None
+        return str(val)
+
     @property
     def total_engram_points(self) -> int:
         """Get total engram points spent."""

{arkparser-0.4.4 → arkparser-0.4.6}/arkparser/files/world_save.py

@@ -31,11 +31,11 @@ from pathlib import Path
 from uuid import UUID
 
 from ..common.binary_reader import BinaryReader
-from ..common.exceptions import ArkParseError
+from ..common.exceptions import ArkParseError, CorruptDataError
 from ..common.normalization import normalize_indexed_data, normalize_indexed_list
 from ..data_models import CryopodCreature
 from ..game_objects.container import GameObjectContainer
-from ..game_objects.game_object import GameObject
+from ..game_objects.game_object import MAX_OBJECT_COUNT, GameObject
 from ..game_objects.location import LocationData
 from ..properties.registry import read_properties
 
@@ -44,6 +44,28 @@ logger = logging.getLogger(__name__)
 # ASE GUIDs are always all-zero; precomputed sentinel skips UUID construction.
 _ZERO_GUID = b"\x00" * 16
 
+# Upper bound on ASA name-table entries (largest observed real table ~4.6k).
+# A count above this means the read is misaligned (a garbage int32 length),
+# so we fail loudly instead of looping over ~billions of phantom entries.
+_MAX_ASA_NAME_TABLE = 1_000_000
+
+
+def _checked_count(reader: BinaryReader, label: str, maximum: int = MAX_OBJECT_COUNT) -> int:
+    """Read a length-prefix int32 and reject corrupt/implausible values.
+
+    Power-of-10 rule 2 (fixed loop bounds): every count that drives a read
+    loop must be provably bounded. A negative or absurd count means a
+    misaligned/corrupt header; raise ``CorruptDataError`` (NOT ``assert`` -
+    asserts vanish under ``python -O``) rather than looping over billions of
+    phantom entries (OOM/hang).
+    """
+    if reader.remaining < 4:
+        raise CorruptDataError(f"{label}: truncated before count int32")
+    count = reader.read_int32()
+    if not 0 <= count <= maximum:
+        raise CorruptDataError(f"{label}: implausible count {count} (corrupt/misaligned read)")
+    return count
+
 
 @dataclass
 class EmbeddedData:
@@ -535,25 +557,25 @@ class WorldSave:
         saved = reader.position
         reader.position = self._name_table_offset
 
-        count = reader.read_int32()
+        count = _checked_count(reader, "ASE name table")
         self.name_table = [reader.read_string() for _ in range(count)]
 
         reader.position = saved
 
     def _read_ase_data_files(self, reader: BinaryReader) -> None:
-        count = reader.read_int32()
+        count = _checked_count(reader, "ASE data files")
         self.data_files = [reader.read_string() for _ in range(count)]
 
     def _read_ase_embedded_data(self, reader: BinaryReader) -> None:
-        count = reader.read_int32()
+        count = _checked_count(reader, "ASE embedded data")
         self.embedded_data = [EmbeddedData.read(reader) for _ in range(count)]
 
     def _read_ase_data_files_object_map(self, reader: BinaryReader) -> None:
-        count = reader.read_int32()
+        count = _checked_count(reader, "ASE data-files object map")
         self.data_files_object_map = {}
         for _ in range(count):
             level = reader.read_int32()
-            name_count = reader.read_int32()
+            name_count = _checked_count(reader, "ASE data-files object names")
             names = [reader.read_string() for _ in range(name_count)]
             self.data_files_object_map.setdefault(level, []).append(names)
 
@@ -608,7 +630,7 @@ class WorldSave:
         return obj
 
     def _read_ase_objects(self, reader: BinaryReader) -> None:
-        count = reader.read_int32()
+        count = _checked_count(reader, "ASE objects")
         self.objects = [self._read_ase_object_header(reader, i) for i in range(count)]
 
     def _read_ase_object_properties(self, reader: BinaryReader) -> None:
@@ -683,50 +705,77 @@ class WorldSave:
         reader = BinaryReader.from_bytes(row[0])
 
         self.version = reader.read_int16()
-        _legacy_offset = reader.read_int32()
-        # v14+ adds two int32 fields (unk1, actual_offset) between
+        legacy_offset = reader.read_int32()
+        # v14+ adds two int32 fields (unk1, name_table_offset) between
         # legacy_offset and game_time; v13 saves jump straight to game_time.
         # Without this version gate we mis-align the read by 8 bytes and the
-        # data_files / name_table loops walk into garbage.
+        # data_files loop walks into garbage.
+        name_table_offset = legacy_offset  # v13: table follows the parts section
         if self.version >= 14:
             _unknown1 = reader.read_int32()
-            _actual_offset = reader.read_int32()
+            name_table_offset = reader.read_int32()  # absolute offset of name table
         self.game_time = reader.read_double()
         _unknown2 = reader.read_int32()
 
-        # Data files
-        count = reader.read_int32()
+        # Data files (immediately follow the header; populate self.data_files).
+        count = _checked_count(reader, "ASA data files")
         self.data_files = []
         for _ in range(count):
             self.data_files.append(reader.read_string())
-            _term = reader.read_int32()
-
-        _pad1 = reader.read_int32()
-        _pad2 = reader.read_int32()
+            _term = reader.read_int32()  # per-entry terminator, always -1
 
-        # Name table (dict keyed by hash for ASA).
+        # Name table (dict keyed by FName hash for ASA).
         #
-        # Most ASA saves serialize the table as a flat ``(hash, strlen,
-        # string)`` triple per entry.  Some maps (observed on Ragnarok,
-        # Scorched Earth and TheIsland on busy servers) prepend
-        # user-placed-structure name entries that carry an extra 4-byte
-        # trailer after the string; those entries always have
-        # ``hash == 1`` as a sentinel.  Detect that sentinel per-entry and
-        # consume the trailer so the rest of the table parses normally.
-        # Without this, parsing the next entry's hash misreads the trailer
-        # as a string length and explodes with EndOfDataError on a ~500 MB
-        # phantom string.
-        name_count = reader.read_int32()
+        # v14+: the engine stores the table at an explicit absolute offset
+        # (name_table_offset = the 2nd int32 after legacy_offset). The bytes
+        # between the data-files section and that offset are NOT a fixed pad
+        # pair on every map - on busy/modded saves (measured: Ragnarok +26 B,
+        # Scorched Earth +31 B past where a sequential read lands) the table
+        # would be read truncated, leaving ~half the class refs resolving to
+        # __UNKNOWN_CLASS_<hash>__. Seek to the offset like the C# reference
+        # (AsaSavegame.readNametable: ``archive.Position = nameTableOffset``).
+        # Where the gap is zero (TheIsland, Aberration, Extinction) the seek is
+        # a no-op; where it drifts it recovers every leaked class name.
+        if self.version >= 14:
+            # Explicit raise (not assert) so the bound survives ``python -O``.
+            if not 0 <= name_table_offset <= reader.size:
+                raise CorruptDataError(
+                    f"ASA name-table offset {name_table_offset} out of range "
+                    f"(blob size {reader.size})"
+                )
+            reader.position = name_table_offset
+            self.name_table = self._read_asa_name_table(reader)
+        else:
+            # v13: no explicit offset field. Retain the historical sequential
+            # read (two pad int32s, then the table) - there is no live v13
+            # fixture to validate a seek against. The idx==1 sentinel consumes
+            # the 4-byte trailer on user-placed-actor entries.
+            reader.read_int32()  # pad1
+            reader.read_int32()  # pad2
+            self.name_table = self._read_asa_name_table(reader, sentinel=True)
+
+    def _read_asa_name_table(
+        self, reader: BinaryReader, sentinel: bool = False
+    ) -> dict[int, str]:
+        """Read an ASA name table (FName-hash -> class string) at ``reader``'s position.
+
+        Preconditions: ``reader`` is positioned at the table's int32 entry
+        count. Postconditions: returns ``{hash: trimmed_class_string}`` (the
+        substring after the last ``.``) and advances the reader past the table.
+        ``sentinel`` consumes the extra 4-byte trailer following
+        user-placed-actor entries (``idx == 1``) on the v13 sequential path; it
+        is unused on the v14 seek path.
+        """
+        name_count = _checked_count(reader, "ASA name table", _MAX_ASA_NAME_TABLE)
         nt: dict[int, str] = {}
         for _ in range(name_count):
             idx = reader.read_int32()
             raw = reader.read_string()
             nt[idx] = raw.rsplit(".", 1)[-1] if "." in raw else raw
-            if idx == 1:
-                # User-placed-actor name sentinel: skip the 4-byte sub-id /
-                # trailing tag that follows on these entries.
+            if sentinel and idx == 1:
+                # User-placed-actor sentinel: skip the trailing 4-byte tag.
                 reader.skip(4)
-        self.name_table = nt
+        return nt
 
     def _read_asa_actor_locations(self, conn: sqlite3.Connection) -> None:
         """Parse the ``ActorTransforms`` blob."""

{arkparser-0.4.4 → arkparser-0.4.6}/arkparser/properties/compound.py

@@ -418,8 +418,17 @@ def _read_array_elements(
         for _ in range(count):
             values.append(reader.read_int8())
     elif array_type == "ByteProperty":
-        for _ in range(count):
-            values.append(reader.read_uint8())
+        # ASE enum byte-arrays store each element as an 8-byte name-table
+        # reference, not a raw uint8. Legacy ArkArrayByteHandler discriminates
+        # on size: data_size > count+4 -> name refs, data_size == count+4 ->
+        # raw uint8. Mirror it so a name-valued byte array doesn't under-read
+        # and drift the cursor into the next property (the cluster-drift class).
+        if not is_asa and count > 0 and data_size > count + 4:
+            for _ in range(count):
+                values.append(read_name(reader, name_table))
+        else:
+            for _ in range(count):
+                values.append(reader.read_uint8())
     elif array_type == "FloatProperty":
         for _ in range(count):
             values.append(reader.read_float())
@@ -540,14 +549,36 @@ def _read_array_elements(
             if reader.position < array_data_end:
                 reader.skip(array_data_end - reader.position)
         else:
-            # ASE struct arrays - read as property-based structs
+            # ASE struct arrays. Resolve the element struct type the way legacy
+            # does (ArkArrayStruct.Init): the array-name map first, else INFER a
+            # native fixed-size type from the body size, where the body is the
+            # int32 count prefix (4) plus count * element_size. Without the size
+            # inference, native struct arrays addressed only by name (e.g.
+            # CustomItemColors = Color[6], data_size 28 = 6*4+4) are misread as
+            # property-list structs, the cursor drifts, and every later property
+            # in the object is corrupted (EndOfDataError on a garbage length).
+            struct_type = struct_registry.get_array_struct_type(array_name)
+            # ASE only: infer the native element type from the body size when the
+            # array name isn't mapped (legacy ArkArrayStruct.Init). Gated to ASE
+            # (not is_asa) so the ASA v6 struct-array path is untouched. The check
+            # is exact, and a property-list element is >= 9 bytes (min "None"
+            # terminator), so these equalities never match a property-list array.
+            if struct_type is None and not is_asa and count > 0:
+                if count * 4 + 4 == data_size:
+                    struct_type = "Color"
+                elif count * 12 + 4 == data_size:
+                    struct_type = "Vector"
+                elif count * 16 + 4 == data_size:
+                    struct_type = "LinearColor"
             for _ in range(count):
-                struct = struct_registry.read_struct_for_array(
-                    reader,
-                    array_name,
-                    is_asa,
-                    name_table=name_table,
-                )
+                if struct_type is not None:
+                    struct = struct_registry.read_struct(
+                        reader, struct_type, is_asa, name_table=name_table
+                    )
+                else:
+                    struct = struct_registry.read_struct_for_array(
+                        reader, array_name, is_asa, name_table=name_table
+                    )
                 if hasattr(struct, "to_dict"):
                     values.append(struct.to_dict())
                 else:
@@ -1206,7 +1237,7 @@ class MapProperty(Property):
         # Handle value type sub-header
         if value_type == "StructProperty":
             _struct_marker = reader.read_int32()  # Usually 1, sometimes 2+
-            struct_type_id = reader.read_int32()
+            _struct_type_id = reader.read_int32()
             _struct_type_inst = reader.read_int32()
             _script_marker = reader.read_int32()
             _script_path_id = reader.read_int32()