arkparser 0.3.1__tar.gz → 0.3.3__tar.gz

{arkparser-0.3.1 → arkparser-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparser
-Version: 0.3.1
+Version: 0.3.3
 Summary: Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files
 Author: Vertyco
 License-Expression: MIT
@@ -210,7 +210,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `hp-m` .. `fort-m` (all 12) | added | `NumberOfMutationsAppliedTamed[i]` (mutation point counts per stat) |
 | `c0` .. `c5` | legacy | `ColorSetIndices[i]` |
 | `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 | `IsInCryo` |
+| `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` |
 | `isMating` | legacy | `bEnableTamedMating` |
@@ -250,6 +250,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `last_baby_age_update` | added | ISO 8601 datetime of `LastUpdatedBabyAgeAtTime`. |
 | `last_gestation_update` | added | ISO 8601 datetime of `LastUpdatedGestationAtTime`. |
 | `next_cuddle` | added | ISO 8601 datetime of `BabyNextCuddleTime`. |
+| `current_stats` | added | Live in-world stat values from the dino's status component (`CurrentStatusValues[0..11]`) as a `{hp, stam, torp, oxy, food, water, temp, weight, melee, speed, fort, craft}` dict of floats. These are the *current* values (e.g. `hp: 11013.62` = current HP, drops as the dino takes damage). Max values are NOT persisted by ARK — compute downstream from species stat tables + `*-w`/`*-t` points + `imprint` + server multipliers if you need them. `null` when the status component carries no `CurrentStatusValues` entries (e.g. uninitialised baby actor). |
 
 #### `ASV_Wild` schema
 
@@ -267,6 +268,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `trait` | legacy | first entry of `CreatureTraits` (or empty string) |
 | `traits` | added | full `CreatureTraits` list |
 | `wild_spawn_region` | added | `OriginalNPCVolumeName` — `NPCZoneVolume` the creature spawned in. |
+| `current_stats` | added | Live in-world stat values from the creature's status component (`CurrentStatusValues[0..11]`) as a `{hp, stam, torp, oxy, food, water, temp, weight, melee, speed, fort, craft}` dict of floats. Max values are NOT in the save (would need species stat tables). `null` when uninitialised. |
 
 #### Player data: `.arkprofile` vs in-world pawn
 
@@ -318,6 +320,7 @@ For the richest output, hand `export_players` **both** — assemble a wrapper fo
 | `corpse_destruction` | added | ISO 8601 datetime of `CorpseDestructionTime`. |
 | `chibi_levels` | added | `NumChibiLevelUps` — bonus levels from chibi pets. |
 | `ascensions_scorched` | added | `NumAscensionsScorched` — ASE ascension counter (legacy `ContentPlayer` parses the ASA ascension block differently; this is the ASE-specific field). |
+| `current_stats` | added | Live in-world stat values for the player from the pawn's `MyCharacterStatusComponent` (`CurrentStatusValues[0..11]`) as a `{hp, stam, torp, oxy, food, water, temp, weight, melee, speed, fort, craft}` dict of floats. For profile-sourced records the parser joins on `PlayerDataID == LinkedPlayerDataID` to find the spawned pawn in the world save. `null` when the player has no in-world pawn (never spawned this server / corpse cleared) or the status component has no values — only currently / recently spawned characters have live stats. Max values are NOT persisted by ARK. |
 
 #### `ASV_Tribes` schema
 

{arkparser-0.3.1 → arkparser-0.3.3}/README.md

@@ -176,7 +176,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `hp-m` .. `fort-m` (all 12) | added | `NumberOfMutationsAppliedTamed[i]` (mutation point counts per stat) |
 | `c0` .. `c5` | legacy | `ColorSetIndices[i]` |
 | `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 | `IsInCryo` |
+| `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` |
 | `isMating` | legacy | `bEnableTamedMating` |
@@ -216,6 +216,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `last_baby_age_update` | added | ISO 8601 datetime of `LastUpdatedBabyAgeAtTime`. |
 | `last_gestation_update` | added | ISO 8601 datetime of `LastUpdatedGestationAtTime`. |
 | `next_cuddle` | added | ISO 8601 datetime of `BabyNextCuddleTime`. |
+| `current_stats` | added | Live in-world stat values from the dino's status component (`CurrentStatusValues[0..11]`) as a `{hp, stam, torp, oxy, food, water, temp, weight, melee, speed, fort, craft}` dict of floats. These are the *current* values (e.g. `hp: 11013.62` = current HP, drops as the dino takes damage). Max values are NOT persisted by ARK — compute downstream from species stat tables + `*-w`/`*-t` points + `imprint` + server multipliers if you need them. `null` when the status component carries no `CurrentStatusValues` entries (e.g. uninitialised baby actor). |
 
 #### `ASV_Wild` schema
 
@@ -233,6 +234,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `trait` | legacy | first entry of `CreatureTraits` (or empty string) |
 | `traits` | added | full `CreatureTraits` list |
 | `wild_spawn_region` | added | `OriginalNPCVolumeName` — `NPCZoneVolume` the creature spawned in. |
+| `current_stats` | added | Live in-world stat values from the creature's status component (`CurrentStatusValues[0..11]`) as a `{hp, stam, torp, oxy, food, water, temp, weight, melee, speed, fort, craft}` dict of floats. Max values are NOT in the save (would need species stat tables). `null` when uninitialised. |
 
 #### Player data: `.arkprofile` vs in-world pawn
 
@@ -284,6 +286,7 @@ For the richest output, hand `export_players` **both** — assemble a wrapper fo
 | `corpse_destruction` | added | ISO 8601 datetime of `CorpseDestructionTime`. |
 | `chibi_levels` | added | `NumChibiLevelUps` — bonus levels from chibi pets. |
 | `ascensions_scorched` | added | `NumAscensionsScorched` — ASE ascension counter (legacy `ContentPlayer` parses the ASA ascension block differently; this is the ASE-specific field). |
+| `current_stats` | added | Live in-world stat values for the player from the pawn's `MyCharacterStatusComponent` (`CurrentStatusValues[0..11]`) as a `{hp, stam, torp, oxy, food, water, temp, weight, melee, speed, fort, craft}` dict of floats. For profile-sourced records the parser joins on `PlayerDataID == LinkedPlayerDataID` to find the spawned pawn in the world save. `null` when the player has no in-world pawn (never spawned this server / corpse cleared) or the status component has no values — only currently / recently spawned characters have live stats. Max values are NOT persisted by ARK. |
 
 #### `ASV_Tribes` schema
 

{arkparser-0.3.1 → arkparser-0.3.3}/arkparser/__init__.py

@@ -91,4 +91,4 @@ __all__ = [
     "ArkParseError",
 ]
 
-__version__ = "0.3.1"
+__version__ = "0.3.3"

{arkparser-0.3.1 → arkparser-0.3.3}/arkparser/data_models.py

@@ -547,20 +547,29 @@ class CryopodCreature:
             ]
 
             if len(floats) >= 22:
-                # Determine offset based on array length
-                # ASA has 36 floats with offset 11, ASE has 25 floats with offset 12
-                max_offset = 11 if len(floats) >= 36 else 12
-
-                # Current stats start at 0
-                for i, stat_name in enumerate(stat_names):
+                # ASA cryopod blob: 11 current stats + 11 max stats + extras (36 floats).
+                # ASE cryopod blob: 12 current stats + 12 max stats + 1 extra (25 floats).
+                # Without the per-format count, the ASA loop walks 12 names against an
+                # 11-wide current block, leaking max[0] (which equals current[0] at full
+                # HP) into current_stats["CraftingSkill"] and surfacing hp=craft on every
+                # cryopod tame in exports.
+                if len(floats) >= 36:
+                    current_count = 11
+                    max_offset = 11
+                else:
+                    current_count = 12
+                    max_offset = 12
+
+                # Current stats: only consume the per-format slot count
+                for i in range(min(current_count, len(stat_names))):
                     if i < len(floats):
-                        cryo.current_stats[stat_name] = floats[i]
+                        cryo.current_stats[stat_names[i]] = floats[i]
 
-                # Max stats start at offset
-                for i, stat_name in enumerate(stat_names):
+                # Max stats: same count, starting at offset
+                for i in range(min(current_count, len(stat_names))):
                     max_idx = i + max_offset
                     if max_idx < len(floats):
-                        cryo.max_stats[stat_name] = floats[max_idx]
+                        cryo.max_stats[stat_names[i]] = floats[max_idx]
 
             # Parse soft class for blueprint reference
             soft_classes = normalize_indexed_list(custom_data.get("CustomDataSoftClasses"))
@@ -569,6 +578,32 @@ class CryopodCreature:
                 if isinstance(first_class, dict):
                     cryo.class_name = first_class.get("name", cryo.class_name)
 
+            # Populate raw creature_props / status_props so the export
+            # pipeline's _SyntheticGameObject adapter (which calls
+            # ``get_property_value``) sees the fields it expects. ARK
+            # cryopod CustomItemDatas blobs only carry a small subset of
+            # the original creature properties (no DinoID, no TribeID, no
+            # tamer string, etc.) — surface what we have, leave the rest
+            # absent so consumers can detect the gap.
+            _stat_to_idx = {
+                "Health": 0, "Stamina": 1, "Torpidity": 2, "Oxygen": 3,
+                "Food": 4, "Water": 5, "Temperature": 6, "Weight": 7,
+                "MeleeDamage": 8, "MovementSpeed": 9, "Fortitude": 10,
+                "CraftingSkill": 11,
+            }
+            if cryo.name:
+                cryo.creature_props["TamedName"] = cryo.name
+            for i, color in enumerate(cryo.colors[:6]):
+                cryo.creature_props[f"ColorSetIndices_{i}" if i > 0 else "ColorSetIndices"] = color
+            if cryo.level:
+                cryo.status_props["BaseCharacterLevel"] = cryo.level
+            for stat_name, value in cryo.current_stats.items():
+                idx = _stat_to_idx.get(stat_name)
+                if idx is None:
+                    continue
+                key = "CurrentStatusValues" if idx == 0 else f"CurrentStatusValues_{idx}"
+                cryo.status_props[key] = value
+
             return cryo
 
         except Exception:

{arkparser-0.3.1 → arkparser-0.3.3}/arkparser/export.py

@@ -203,6 +203,57 @@ def _stat_array(status: t.Any, prop_name: str) -> list[int]:
     return out
 
 
+def _current_stat_floats(status: t.Any) -> list[float] | None:
+    """Read ``CurrentStatusValues[0..11]`` from a character status component.
+
+    Status components persist the live in-world values of all 12 stats. The
+    array is indexed by ARK's ``EPrimalCharacterStatusValue`` enum:
+    0=hp, 1=stam, 2=torpor, 3=oxy, 4=food, 5=water, 6=temp, 7=weight,
+    8=melee, 9=speed, 10=temp-fortitude, 11=crafting.
+
+    Returns ``None`` when the status component is missing or carries no
+    CurrentStatusValues entries (e.g. uninitialised baby actor) so callers
+    can distinguish "no data" from "all zeros".
+    """
+    if status is None:
+        return None
+    out: list[float] = [0.0] * 12
+    seen = False
+    getter = getattr(status, "get_properties_by_name", None)
+    if callable(getter):
+        # Real GameObject: get_properties_by_name surfaces every indexed
+        # entry. Empty result == component carries no CurrentStatusValues
+        # at all (uninitialised); return None so callers can distinguish
+        # "no data" from "all zeros".
+        for prop in getter("CurrentStatusValues"):
+            idx = getattr(prop, "index", 0)
+            if 0 <= idx < 12:
+                out[idx] = _float(getattr(prop, "value", 0.0))
+                seen = True
+        return out if seen else None
+    # Synthetic / cryopod stand-in: per-index get_property_value lookups.
+    for i in range(12):
+        val = _prop(status, "CurrentStatusValues", default=None, index=i)
+        if val is not None:
+            out[i] = _float(val)
+            seen = True
+    return out if seen else None
+
+
+def _current_stats_dict(status: t.Any) -> dict[str, float] | None:
+    """Return current stat values keyed by short stat name.
+
+    Pre-conditions: ``status`` is the character status component (creature or
+    player). May be ``None`` (e.g. offline player with no spawned pawn).
+    Post-conditions: returns a dict ``{hp, stam, ..., craft}`` of floats, or
+    ``None`` when no CurrentStatusValues are persisted on the component.
+    """
+    floats = _current_stat_floats(status)
+    if floats is None:
+        return None
+    return {_STAT_NAMES[i]: floats[i] for i in range(12)}
+
+
 def _flat_stats(points: list[int], suffix: str = "") -> dict[str, int]:
     """Emit all 12 stats as a flat dict.
 
@@ -674,6 +725,7 @@ def _tamed_dict(
             )) is not None
             else None
         ),
+        "current_stats": _current_stats_dict(status),
         "imprinter_player_id": _int(_prop(obj, "ImprinterPlayerDataID")),
         "imprinter_net_id": _str(_prop(obj, "ImprinterPlayerUniqueNetId")),
         "taming_team_id": _int(_prop(obj, "TamingTeamID")),
@@ -719,12 +771,55 @@ def _tamed_dict(
 
 
 def export_tamed(save: t.Any, map_config: MapConfig | None = None) -> list[dict[str, t.Any]]:
+    """Emit ASV_Tamed records.
+
+    Pre-conditions: ``save`` exposes ``get_tamed_creatures()`` (in-world
+    tames) and ideally ``iter_cryopod_creatures()`` (creatures whose actor
+    has been removed from the world and re-embedded inside a cryopod /
+    soultrap / vivarium / dinoball item).
+
+    Post-conditions: returned list combines (a) every in-world tame and
+    (b) every cryopod-embedded tame, with the latter carrying ``cryo=True``
+    and inheriting the cryopod item's world location for GPS fields.
+    """
     objects = _world_objects(save, "get_tamed_creatures", "tamed_objects")
     lookup = _save_lookup(save)
-    return [
+    results: list[dict[str, t.Any]] = [
         _tamed_dict(obj, _status_for(obj, lookup), lookup, map_config, save)
         for obj in objects
     ]
+    results.extend(_export_world_cryopods(save, map_config))
+    return results
+
+
+def _export_world_cryopods(
+    save: t.Any,
+    map_config: MapConfig | None,
+) -> list[dict[str, t.Any]]:
+    """Build ASV_Tamed records for cryopod-embedded creatures on the map.
+
+    ARK strips the actor for any creature stuffed into a cryopod / soultrap
+    / vivarium / dinoball and serialises a snapshot into the item's
+    ``CustomItemDatas``. ``get_tamed_creatures()`` therefore misses them
+    entirely. We walk ``iter_cryopod_creatures()`` (when available),
+    decode each embedded blob, and produce ``ASV_Tamed`` entries with
+    ``cryo=True`` and the cryopod item's location.
+    """
+    iter_cryos = getattr(save, "iter_cryopod_creatures", None)
+    if not callable(iter_cryos):
+        return []
+    out: list[dict[str, t.Any]] = []
+    empty_lookup: dict[t.Any, t.Any] = {}
+    for item_obj, cryo in iter_cryos():
+        actor, status = _cryo_props_to_synthetic(cryo)
+        # Inherit the cryopod's world location so GPS fields populate.
+        actor.location = getattr(item_obj, "location", None)
+        record = _tamed_dict(actor, status, empty_lookup, map_config, save)
+        # The synthetic actor carries no IsInCryo property; force the legacy
+        # flag so consumers can distinguish in-world tames from stored ones.
+        record["cryo"] = True
+        out.append(record)
+    return out
 
 
 class _SyntheticGameObject:
@@ -870,6 +965,7 @@ def _wild_dict(
         # CreatureTraits list is exposed alongside as ``traits``.
         "trait": traits[0] if traits else "",
         "traits": traits,
+        "current_stats": _current_stats_dict(status),
         "wild_spawn_region": _str(_prop(obj, "OriginalNPCVolumeName")),
     }
     data.update(_gps_payload(obj, map_config))
@@ -882,13 +978,24 @@ def export_wild(save: t.Any, map_config: MapConfig | None = None) -> list[dict[s
     return [_wild_dict(obj, _status_for(obj, lookup), map_config) for obj in objects]
 
 
-def _player_from_profile(profile: Profile, save: t.Any = None) -> dict[str, t.Any]:
+def _player_from_profile(
+    profile: Profile,
+    save: t.Any = None,
+    pawn_status_by_id: dict[int, t.Any] | None = None,
+) -> dict[str, t.Any]:
     stat_points = [_int(profile.get_stat(i)["added"]) for i in range(12)]
     gamertag = profile.player_name or ""
     character = profile.character_name or gamertag
     steam_id = profile.unique_id or ""
     active_dt = _approx_real_datetime(profile.last_login_time, save)
 
+    # Live HP/stam/etc live on the player's in-world pawn's status component,
+    # not in the profile. Resolve via PlayerDataID -> pawn -> status. Absent
+    # when the player has no spawned body (never spawned / corpse cleared).
+    status = None
+    if pawn_status_by_id and profile.player_id:
+        status = pawn_status_by_id.get(int(profile.player_id))
+
     out: dict[str, t.Any] = {
         "playerid": profile.player_id or 0,
         "steam": _str(gamertag),
@@ -907,6 +1014,7 @@ def _player_from_profile(profile: Profile, save: t.Any = None) -> dict[str, t.An
         "netAddress": "",
         "engram_points": profile.total_engram_points,
         "experience": _int(profile.experience),
+        "current_stats": _current_stats_dict(status),
     }
     if steam_id:
         out["steamid"] = steam_id
@@ -981,17 +1089,43 @@ def _player_from_object(
         "body_colors": body_colors,
         "died_at": died_iso,
         "corpse_destruction": corpse_iso,
+        "current_stats": _current_stats_dict(status),
     }
     return _compact(data, LEGACY_PLAYER_KEYS)
 
 
+def _player_status_by_data_id(save: t.Any, lookup: dict[t.Any, t.Any]) -> dict[int, t.Any]:
+    """Index ``MyCharacterStatusComponent`` per player by ``LinkedPlayerDataID``.
+
+    Walks every ``PlayerPawnTest_*_C`` / ``PlayerCharacter_*`` in the world
+    save, reads its ``LinkedPlayerDataID``, follows ``MyCharacterStatusComponent``
+    via ``lookup``, and stores the resolved status object. Lets profile-based
+    player exports surface live HP/stamina/food/etc. without legacy ASVPack
+    having to do the same join.
+    """
+    out: dict[int, t.Any] = {}
+    objects = getattr(save, "objects", None) or []
+    for obj in objects:
+        cn = str(getattr(obj, "class_name", "") or "")
+        if "PlayerPawn" not in cn and "PlayerCharacter" not in cn:
+            continue
+        pid = _int(_prop(obj, "LinkedPlayerDataID"))
+        if not pid:
+            continue
+        status = _status_for(obj, lookup)
+        if status is not None:
+            out[pid] = status
+    return out
+
+
 def export_players(save: t.Any, map_config: MapConfig | None = None) -> list[dict[str, t.Any]]:
     profiles = _collection(save, "profiles", Profile)
     lookup = _save_lookup(save)
+    pawn_status_by_id = _player_status_by_data_id(save, lookup)
     results: list[dict[str, t.Any]] = []
     for entry in profiles:
         if isinstance(entry, Profile):
-            results.append(_player_from_profile(entry, save))
+            results.append(_player_from_profile(entry, save, pawn_status_by_id))
             continue
         profile_obj = getattr(entry, "profile", None)
         if profile_obj is None and getattr(entry, "objects", None):

{arkparser-0.3.1 → arkparser-0.3.3}/arkparser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arkparser
-Version: 0.3.1
+Version: 0.3.3
 Summary: Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files
 Author: Vertyco
 License-Expression: MIT
@@ -210,7 +210,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `hp-m` .. `fort-m` (all 12) | added | `NumberOfMutationsAppliedTamed[i]` (mutation point counts per stat) |
 | `c0` .. `c5` | legacy | `ColorSetIndices[i]` |
 | `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 | `IsInCryo` |
+| `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` |
 | `isMating` | legacy | `bEnableTamedMating` |
@@ -250,6 +250,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `last_baby_age_update` | added | ISO 8601 datetime of `LastUpdatedBabyAgeAtTime`. |
 | `last_gestation_update` | added | ISO 8601 datetime of `LastUpdatedGestationAtTime`. |
 | `next_cuddle` | added | ISO 8601 datetime of `BabyNextCuddleTime`. |
+| `current_stats` | added | Live in-world stat values from the dino's status component (`CurrentStatusValues[0..11]`) as a `{hp, stam, torp, oxy, food, water, temp, weight, melee, speed, fort, craft}` dict of floats. These are the *current* values (e.g. `hp: 11013.62` = current HP, drops as the dino takes damage). Max values are NOT persisted by ARK — compute downstream from species stat tables + `*-w`/`*-t` points + `imprint` + server multipliers if you need them. `null` when the status component carries no `CurrentStatusValues` entries (e.g. uninitialised baby actor). |
 
 #### `ASV_Wild` schema
 
@@ -267,6 +268,7 @@ The legacy ASVExport.exe emitted only the visible 8 stats (`hp`, `stam`, `melee`
 | `trait` | legacy | first entry of `CreatureTraits` (or empty string) |
 | `traits` | added | full `CreatureTraits` list |
 | `wild_spawn_region` | added | `OriginalNPCVolumeName` — `NPCZoneVolume` the creature spawned in. |
+| `current_stats` | added | Live in-world stat values from the creature's status component (`CurrentStatusValues[0..11]`) as a `{hp, stam, torp, oxy, food, water, temp, weight, melee, speed, fort, craft}` dict of floats. Max values are NOT in the save (would need species stat tables). `null` when uninitialised. |
 
 #### Player data: `.arkprofile` vs in-world pawn
 
@@ -318,6 +320,7 @@ For the richest output, hand `export_players` **both** — assemble a wrapper fo
 | `corpse_destruction` | added | ISO 8601 datetime of `CorpseDestructionTime`. |
 | `chibi_levels` | added | `NumChibiLevelUps` — bonus levels from chibi pets. |
 | `ascensions_scorched` | added | `NumAscensionsScorched` — ASE ascension counter (legacy `ContentPlayer` parses the ASA ascension block differently; this is the ASE-specific field). |
+| `current_stats` | added | Live in-world stat values for the player from the pawn's `MyCharacterStatusComponent` (`CurrentStatusValues[0..11]`) as a `{hp, stam, torp, oxy, food, water, temp, weight, melee, speed, fort, craft}` dict of floats. For profile-sourced records the parser joins on `PlayerDataID == LinkedPlayerDataID` to find the spawned pawn in the world save. `null` when the player has no in-world pawn (never spawned this server / corpse cleared) or the status component has no values — only currently / recently spawned characters have live stats. Max values are NOT persisted by ARK. |
 
 #### `ASV_Tribes` schema
 

{arkparser-0.3.1 → arkparser-0.3.3}/arkparser.egg-info/SOURCES.txt

@@ -43,6 +43,8 @@ tests/test_asa_header_position.py
 tests/test_binary_reader.py
 tests/test_binary_reader_layouts.py
 tests/test_cloud_inventory.py
+tests/test_cryopod_export.py
+tests/test_current_stats.py
 tests/test_data_models.py
 tests/test_export.py
 tests/test_game_objects.py

{arkparser-0.3.1 → arkparser-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "arkparser"
-version = "0.3.1"
+version = "0.3.3"
 description = "Pure Python parser for ARK: Survival Evolved and ARK: Survival Ascended save files"
 readme = "README.md"
 license = "MIT"

arkparser-0.3.3/tests/test_cryopod_export.py

@@ -0,0 +1,122 @@
+"""Tests pinning ASA cryopod creature decode + export integration.
+
+ARK strips the actor for every cryopodded / soultrapped / vivariumed /
+dinoballed creature and embeds a serialised snapshot into the item's
+``CustomItemDatas``. ``WorldSave.iter_cryopod_creatures`` walks these
+items, and ``export_tamed`` then surfaces them as ``ASV_Tamed`` entries
+with ``cryo=True``. Two regressions tested here:
+
+- ASA cryopod blobs carry 11 current stats (no CraftingSkill in the
+  current block), 11 max stats, and 14 extras (36 floats total). The
+  pre-0.3.3 parser walked 12 names against an 11-wide block, leaking
+  ``max[0]`` (Health) into ``current_stats["CraftingSkill"]`` and
+  surfacing ``hp == craft`` on every cryopod tame.
+- ``from_asa_cryopod_data`` did not populate ``creature_props`` /
+  ``status_props``; the ``_SyntheticGameObject`` adapter the exporter
+  uses then saw empty dicts and emitted records with ``lvl=1``,
+  ``name=""``, all-zero colors, and ``current_stats: null``.
+"""
+
+from __future__ import annotations
+
+from arkparser.data_models import CryopodCreature
+
+
+def _asa_blob(current: list[float], max_: list[float]) -> dict[str, object]:
+    """Synthesise the smallest ASA cryopod CustomItemDatas entry we can.
+
+    36 floats total: 11 current + 11 max + 14 extras (zeros).
+    """
+    assert len(current) == 11
+    assert len(max_) == 11
+    floats = current + max_ + [0.0] * 14
+    return {
+        "CustomDataName": "Dino",
+        "CustomDataStrings": [
+            "Argent_Character_BP_C_2094073921",  # [0] class_name
+            "dada - Lvl 259 (Argentavis)",       # [1] display
+            "37,0,37,0,0,0,",                    # [2] colors
+            "", "", "", "", "", "", "Argentavis",  # [9] species
+        ],
+        "CustomDataFloats": floats,
+        "CustomDataNames": [],
+    }
+
+
+def test_asa_cryopod_eleven_current_stats_does_not_leak_max_into_craft() -> None:
+    """ASA cryopod blob: current[0..10] then max[0..10]. craft must come
+    from current[11] — which does not exist, so it must stay 0.0, NOT pick
+    up max[0]."""
+    current = [6206.46, 2411.2, 0.0, 750.0, 13153.03, 100.0, 0.0, 63.6, 6.69, 0.09, 0.0]
+    max_ = [6206.46, 2411.2, 0.0, 750.0, 13153.03, 100.0, 0.0, 63.6, 6.69, 0.09, 0.0]
+    cryo = CryopodCreature.from_asa_cryopod_data(_asa_blob(current, max_))
+    assert cryo is not None
+    assert "Health" in cryo.current_stats
+    assert cryo.current_stats["Health"] == 6206.46
+    # CraftingSkill must NOT be in current_stats on ASA cryopods (only
+    # 11 slots are populated). Pre-0.3.3 set it equal to max[0]=Health.
+    assert "CraftingSkill" not in cryo.current_stats
+    # Max block round-trips properly
+    assert cryo.max_stats["Health"] == 6206.46
+
+
+def test_asa_cryopod_populates_creature_and_status_props() -> None:
+    """The exporter adapter (``_SyntheticGameObject``) reads via
+    ``get_property_value`` keyed by ARK property name + index suffix. The
+    ASA cryopod decoder must mirror those keys into ``creature_props`` /
+    ``status_props`` so the synthetic adapter surfaces tamed-name, level,
+    colors, and CurrentStatusValues per stat index."""
+    current = [3000.0, 800.0, 0.0, 500.0, 5000.0, 100.0, 0.0, 200.0, 2.5, 0.05, 0.0]
+    max_ = [3000.0] * 11
+    cryo = CryopodCreature.from_asa_cryopod_data(_asa_blob(current, max_))
+    assert cryo is not None
+
+    # TamedName from display-name parse
+    assert cryo.creature_props.get("TamedName") == "dada"
+    # Level from display-name parse
+    assert cryo.status_props.get("BaseCharacterLevel") == 259
+    # Colors at expected indices (first non-zero is c0=37, then c2=37)
+    assert cryo.creature_props.get("ColorSetIndices") == 37
+    assert cryo.creature_props.get("ColorSetIndices_2") == 37
+    # CurrentStatusValues indexed by EPrimalCharacterStatusValue
+    # 0=Health, 1=Stamina, 3=Oxygen, 4=Food, 7=Weight, 8=MeleeDamage
+    assert cryo.status_props.get("CurrentStatusValues") == 3000.0      # health
+    assert cryo.status_props.get("CurrentStatusValues_1") == 800.0     # stam
+    assert cryo.status_props.get("CurrentStatusValues_4") == 5000.0    # food
+    assert cryo.status_props.get("CurrentStatusValues_7") == 200.0     # weight
+    assert cryo.status_props.get("CurrentStatusValues_8") == 2.5       # melee
+
+
+def test_asa_cryopod_display_name_parses_level_and_species() -> None:
+    """Display-name format ``"Name - Lvl N (Species)"`` must yield all three."""
+    cryo = CryopodCreature.from_asa_cryopod_data(_asa_blob([0.0] * 11, [0.0] * 11))
+    assert cryo is not None
+    assert cryo.name == "dada"
+    assert cryo.level == 259
+    # Species comes from strings[9] when present, falling back to display parse
+    assert cryo.species == "Argentavis"
+
+
+def test_ase_cryopod_keeps_twelve_stat_layout() -> None:
+    """ASE cryopod blobs carry 12 current stats + 12 max stats (25 floats).
+    The ASA fix must not break the ASE path: walking all 12 names is the
+    correct behaviour when ``len(floats) < 36``."""
+    # 25 floats = 12 current + 12 max + 1 extra
+    floats = [float(i + 1) for i in range(12)] + [float(i + 100) for i in range(12)] + [0.0]
+    blob = {
+        "CustomDataName": "Dino",
+        "CustomDataStrings": [
+            "Raptor_Character_BP_C", "Bluey - Lvl 30 (Raptor)", "0,0,0,0,0,0,",
+        ],
+        "CustomDataFloats": floats,
+        "CustomDataNames": [],
+    }
+    cryo = CryopodCreature.from_asa_cryopod_data(blob)
+    assert cryo is not None
+    # All 12 current and 12 max should be populated on ASE blobs
+    assert len(cryo.current_stats) == 12
+    assert len(cryo.max_stats) == 12
+    assert cryo.current_stats["Health"] == 1.0
+    assert cryo.current_stats["CraftingSkill"] == 12.0
+    assert cryo.max_stats["Health"] == 100.0
+    assert cryo.max_stats["CraftingSkill"] == 111.0

arkparser-0.3.3/tests/test_current_stats.py

@@ -0,0 +1,133 @@
+"""Unit tests for live CurrentStatusValues extraction.
+
+ARK persists every character's instantaneous stat values on the status
+component as ``CurrentStatusValues[0..11]``. ``_current_stats_dict`` reads
+those entries (using either ``get_properties_by_name`` for objects that
+expose it or per-index ``get_property_value`` lookups for synthetic /
+cryopod objects) and returns ``{hp, stam, torp, oxy, food, water, temp,
+weight, melee, speed, fort, craft}``.
+"""
+
+from __future__ import annotations
+
+import typing as t
+from dataclasses import dataclass
+
+from arkparser.export import _current_stat_floats, _current_stats_dict
+
+_STAT_ORDER = (
+    "hp", "stam", "torp", "oxy", "food", "water",
+    "temp", "weight", "melee", "speed", "fort", "craft",
+)
+
+
+@dataclass
+class _IndexedProp:
+    """Stand-in for an arkparser property with an array index."""
+
+    name: str
+    index: int
+    value: float
+
+
+class _FakeStatus:
+    """Minimal stand-in for a character status component.
+
+    Supports the ``get_properties_by_name`` interface used by
+    ``_current_stat_floats``.
+    """
+
+    def __init__(self, current: list[tuple[int, float]]) -> None:
+        self._props = [_IndexedProp("CurrentStatusValues", idx, val) for idx, val in current]
+
+    def get_properties_by_name(self, name: str) -> list[_IndexedProp]:
+        return [p for p in self._props if p.name == name]
+
+
+class _PerIndexStatus:
+    """Synthetic stand-in (matches ``_SyntheticGameObject`` interface).
+
+    Stores values as ``CurrentStatusValues_{idx}`` keys, and
+    ``get_property_value`` returns the indexed value.
+    """
+
+    def __init__(self, current: dict[int, float]) -> None:
+        self._values = current
+
+    def get_property_value(
+        self,
+        name: str,
+        default: t.Any = None,
+        index: int | None = None,
+    ) -> t.Any:
+        if name != "CurrentStatusValues":
+            return default
+        if index is None:
+            return default
+        return self._values.get(index, default)
+
+
+def test_none_status_returns_none() -> None:
+    assert _current_stat_floats(None) is None
+    assert _current_stats_dict(None) is None
+
+
+def test_empty_status_returns_none() -> None:
+    """Status component carrying no CurrentStatusValues at all -> ``None``."""
+    status = _FakeStatus(current=[])
+    assert _current_stat_floats(status) is None
+    assert _current_stats_dict(status) is None
+
+
+def test_sparse_indices_fill_with_zeros() -> None:
+    """Real saves only persist the stats that diverge from defaults; the
+    rest get zero. Wyvern test: hp + stam + oxy set, the rest zero."""
+    status = _FakeStatus(current=[
+        (0, 25238.14),   # hp
+        (1, 806.40),     # stam
+        (3, 660.0),      # oxy
+    ])
+    result = _current_stats_dict(status)
+    assert result is not None
+    assert result["hp"] == 25238.14
+    assert result["stam"] == 806.40
+    assert result["oxy"] == 660.0
+    assert result["torp"] == 0.0
+    assert result["food"] == 0.0
+    assert result["water"] == 0.0
+    assert result["weight"] == 0.0
+    assert result["melee"] == 0.0
+    assert result["speed"] == 0.0
+    assert result["temp"] == 0.0
+    assert result["fort"] == 0.0
+    assert result["craft"] == 0.0
+
+
+def test_all_twelve_indices_round_trip() -> None:
+    """Verify every stat slot maps to the correct name (catches off-by-one)."""
+    status = _FakeStatus(current=[(i, float(i + 1) * 10) for i in range(12)])
+    result = _current_stats_dict(status)
+    assert result is not None
+    for i, name in enumerate(_STAT_ORDER):
+        assert result[name] == float(i + 1) * 10, f"slot {i} ({name}) mismatched"
+
+
+def test_synthetic_object_uses_per_index_getter() -> None:
+    """Cryopod-decoded creatures expose status via ``get_property_value``
+    with an explicit ``index`` arg, not ``get_properties_by_name``."""
+    status = _PerIndexStatus(current={0: 1000.0, 1: 500.0, 4: 3000.0})
+    result = _current_stats_dict(status)
+    assert result is not None
+    assert result["hp"] == 1000.0
+    assert result["stam"] == 500.0
+    assert result["food"] == 3000.0
+    assert result["torp"] == 0.0
+
+
+def test_out_of_range_indices_are_ignored() -> None:
+    """Defensive: stray index 12+ entries must not blow past the 12-slot array."""
+    status = _FakeStatus(current=[(0, 100.0), (12, 999.0), (15, 999.0)])
+    result = _current_stats_dict(status)
+    assert result is not None
+    assert result["hp"] == 100.0
+    assert len(result) == 12