cs2df 3.0.0__tar.gz → 3.0.2__tar.gz

{cs2df-3.0.0 → cs2df-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cs2df
-Version: 3.0.0
+Version: 3.0.2
 Summary: Reference exporter & validator CLI for cs2-demo-format v3 (CS2 demo → ZIP data package)
 Project-URL: Homepage, https://github.com/Starfie1d1272/cs2-demo-format
 Project-URL: Repository, https://github.com/Starfie1d1272/cs2-demo-format

{cs2df-3.0.0 → cs2df-3.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cs2df"
-version = "3.0.0"
+version = "3.0.2"
 description = "Reference exporter & validator CLI for cs2-demo-format v3 (CS2 demo → ZIP data package)"
 readme = "README.md"
 requires-python = ">=3.11"

{cs2df-3.0.0 → cs2df-3.0.2}/src/cs2df/enums.py

@@ -124,6 +124,14 @@ _GRENADE_ITEMS = {
     "Smoke Grenade", "Flashbang", "High Explosive Grenade",
     "Incendiary Grenade", "Molotov", "Decoy Grenade",
 }
+_GRENADE_ITEM_TO_TYPE = {
+    "Smoke Grenade": "smoke",
+    "Flashbang": "flashbang",
+    "High Explosive Grenade": "hegrenade",
+    "Incendiary Grenade": "incendiary",
+    "Molotov": "molotov",
+    "Decoy Grenade": "decoy",
+}
 _PISTOL_ITEMS = {
     "Glock-18", "USP-S", "P2000", "Dual Berettas", "P250", "Five-SeveN",
     "Tec-9", "CZ75-Auto", "Desert Eagle", "R8 Revolver",
@@ -141,27 +149,28 @@ _PRIMARY_ITEMS = {
 }
 
 
-def classify_inventory(items: Any) -> tuple[str | None, str | None, int]:
-    """Return (primaryWeapon, secondaryWeapon, grenadeCount) from an inventory list.
+def classify_inventory(items: Any) -> tuple[str | None, str | None, int, list[str]]:
+    """Return (primaryWeapon, secondaryWeapon, grenadeCount, grenades) from an inventory list.
 
     primary/secondary are the first matching gun in each slot; grenadeCount counts
-    grenade items (max 4 per CS2 rules, not clamped here). Non-weapons (knife, C4,
-    Zeus) and unknown names are ignored.
+    grenade items (max 4 per CS2 rules, not clamped here), while grenades preserves
+    the normalized held utility types. Non-weapons (knife, C4, Zeus) and unknown
+    names are ignored.
     """
     if not isinstance(items, (list, tuple)):
-        return None, None, 0
+        return None, None, 0, []
     primary: str | None = None
     secondary: str | None = None
-    grenades = 0
+    grenade_types: list[str] = []
     for it in items:
         name = str(it or "").strip()
         if name in _GRENADE_ITEMS:
-            grenades += 1
+            grenade_types.append(_GRENADE_ITEM_TO_TYPE[name])
         elif primary is None and name in _PRIMARY_ITEMS:
             primary = name
         elif secondary is None and name in _PISTOL_ITEMS:
             secondary = name
-    return primary, secondary, grenades
+    return primary, secondary, len(grenade_types), grenade_types
 
 
 # ── active weapon normalization ───────────────────────────────────────────────

{cs2df-3.0.0 → cs2df-3.0.2}/src/cs2df/events.py

@@ -653,7 +653,7 @@ def build_economies(raw: dict, players: PlayerDirectory, round_model: _RoundMode
         equip = int(_safe_float(r.get("current_equip_value"), 0))
         start_money = int(_safe_float(r.get("start_balance"), 0))
         eco_type = _economy_type(spent, start_money, equip, n)
-        primary, secondary, grenade_count = classify_inventory(r.get("inventory"))
+        primary, secondary, grenade_count, grenades = classify_inventory(r.get("inventory"))
 
         out.append({
             "roundNumber": n,
@@ -668,6 +668,7 @@ def build_economies(raw: dict, players: PlayerDirectory, round_model: _RoundMode
             "primaryWeapon": primary,
             "secondaryWeapon": secondary,
             "grenadeCount": grenade_count,
+            "grenades": grenades,
         })
         team_round_types.setdefault((n, key), []).append(eco_type)
 

{cs2df-3.0.0 → cs2df-3.0.2}/src/cs2df/parse.py

@@ -48,13 +48,14 @@ _GRENADE_EVENTS = [
 # (raw userid is an entity slot, not a Steam64).
 _GRENADE_PLAYER_FIELDS = ["steamid", "X", "Y", "Z"]
 
-# Per-frame props for the replay grid. No `inventory`, no `has_c4` — see module
-# docstring. `balance` is the cash account (replay `money` column);
+# Per-frame props for the replay grid. `inventory` is sampled here so replay
+# consumers can render current held utility; full-tick paths still avoid it.
+# `balance` is the cash account (replay `money` column);
 # `current_equip_value` is the equipment value (`equipValue` column).
 _REPLAY_PROPS = [
     "steamid", "team_num", "X", "Y", "Z", "yaw", "pitch",
     "health", "armor", "active_weapon_name", "flash_duration",
-    "balance", "current_equip_value", "has_defuser", "last_place_name",
+    "balance", "current_equip_value", "has_defuser", "last_place_name", "inventory",
 ]
 
 # Lean per-frame props for full-tick duel windows.
@@ -129,6 +130,68 @@ def _safe_ticks_df(parser: DemoParser, props: list[str], ticks: list[int]) -> "p
     return None
 
 
+def _rebuild_blinds(parser: DemoParser, detonates: list[dict]) -> list[dict]:
+    """Reconstruct per-victim blind rows from flashbang_detonate + flash_duration.
+
+    Newer demoparser2 builds no longer emit the player_blind game event; the only
+    flash signal left is flashbang_detonate (thrower + position) plus the
+    per-player flash_duration tick property. A player whose flash_duration jumps
+    across a detonate tick was blinded by that flash; the post-detonate value is
+    the (remaining ≈ full) blind duration. When several flashes pop on the same
+    tick, attribute by closest detonate position.
+    """
+    det_by_tick: dict[int, list[dict]] = {}
+    for d in detonates:
+        tick = int(d.get("tick") or 0)
+        if tick > 0:
+            det_by_tick.setdefault(tick, []).append(d)
+    if not det_by_tick:
+        return []
+    det_ticks = sorted(det_by_tick)
+    sample_ticks = sorted({t - 1 for t in det_ticks} | {t + 2 for t in det_ticks})
+    df = _safe_ticks_df(parser, ["flash_duration", "X", "Y"], sample_ticks)
+    if df is None or df.empty or "flash_duration" not in df.columns:
+        return []
+
+    state: dict[tuple[int, str], tuple[float, float | None, float | None]] = {}
+    has_xy = "X" in df.columns and "Y" in df.columns
+    for row in df.itertuples(index=False):
+        d = row._asdict()
+        sid = d.get("steamid")
+        if sid is None:
+            continue
+        fd = float(d.get("flash_duration") or 0.0)
+        x = float(d["X"]) if has_xy and d.get("X") is not None else None
+        y = float(d["Y"]) if has_xy and d.get("Y") is not None else None
+        state[(int(d["tick"]), str(int(sid)))] = (fd, x, y)
+
+    out: list[dict] = []
+    sids = {sid for (_, sid) in state}
+    for tick in det_ticks:
+        dets = det_by_tick[tick]
+        for sid in sids:
+            before = state.get((tick - 1, sid), (0.0, None, None))[0]
+            after_state = state.get((tick + 2, sid))
+            if after_state is None:
+                continue
+            after, px, py = after_state
+            if after <= before + 0.1:
+                continue
+            det = dets[0]
+            if len(dets) > 1 and px is not None and py is not None:
+                det = min(
+                    dets,
+                    key=lambda d: (float(d.get("x") or 0.0) - px) ** 2 + (float(d.get("y") or 0.0) - py) ** 2,
+                )
+            out.append({
+                "tick": tick,
+                "attacker_steamid": det.get("user_steamid"),
+                "user_steamid": sid,
+                "blind_duration": after,
+            })
+    return out
+
+
 def parse_demo(dem_path: str, *, sample_rate: int = 8, research: bool = False,
                window_before_ms: int = 2000, window_after_ms: int = 1000,
                progress: ProgressFn | None = None) -> dict[str, Any]:
@@ -171,6 +234,14 @@ def parse_demo(dem_path: str, *, sample_rate: int = 8, research: bool = False,
     )
     _record("parse.roundEvents", stage_started)
 
+    # demoparser2 新版已移除 player_blind 事件：用 flashbang_detonate + flash_duration
+    # tick 采样重建逐人致盲数据（旧版仍发 player_blind 时维持原路径）。
+    if not g_round["player_blind"]:
+        stage_started = time.perf_counter()
+        detonates = _safe_event(p, "flashbang_detonate")
+        g_round["player_blind"] = _rebuild_blinds(p, detonates)
+        _record("parse.blindRebuild", stage_started)
+
     _p("kills", 0.12)
     stage_started = time.perf_counter()
     deaths = _safe_event(p, "player_death",

{cs2df-3.0.0 → cs2df-3.0.2}/src/cs2df/streams.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from .enums import normalize_weapon_name
+from .enums import classify_inventory, normalize_weapon_name
 from .events import PlayerDirectory, _sid
 from .rounds import _RoundModel
 
@@ -153,6 +153,10 @@ def build_replay(raw: dict, players: PlayerDirectory, round_model: _RoundModel,
         if str(v).strip()
     }
     df["_plidx"] = df["last_place_name"].map(place_map).fillna(-1).astype("int64")
+    if "inventory" in df.columns:
+        df["_grenades"] = df["inventory"].map(lambda items: classify_inventory(items)[3])
+    else:
+        df["_grenades"] = [[] for _ in range(len(df))]
 
     bomb_ticks, bomb_carrier = build_bomb_carrier_timeline(raw, players)
     tick_values = df["tick"].to_numpy()
@@ -249,6 +253,7 @@ def _player_track(g, grid, pidx: int, bomb_ticks, bomb_carrier) -> dict | None:
     widx = np.where(present, widx, -1)
     plidx = aligned["_plidx"].fillna(-1).astype("int64").to_numpy()
     plidx = np.where(present, plidx, -1)
+    grenades = _align_grenades(aligned, present)
 
     alive = (hp > 0).astype("int64")
     has_kit = _num(aligned["has_defuser"], 0.0).to_numpy().astype(bool)
@@ -270,9 +275,24 @@ def _player_track(g, grid, pidx: int, bomb_ticks, bomb_carrier) -> dict | None:
         "place": plidx.tolist(),
         "flash": flash.tolist(),
         "flags": flags.tolist(),
+        "grenades": grenades,
     }
 
 
+def _align_grenades(aligned, present) -> list[list[str]]:
+    """Forward-fill sampled inventory lists and clear them when no player row exists."""
+    if "_grenades" not in aligned.columns:
+        return [[] for _ in range(len(aligned))]
+    filled = aligned["_grenades"].ffill().bfill()
+    out: list[list[str]] = []
+    for has_row, value in zip(present, filled, strict=False):
+        if not has_row or not isinstance(value, list):
+            out.append([])
+        else:
+            out.append([str(item) for item in value])
+    return out
+
+
 # ── duels.json ────────────────────────────────────────────────────────────────
 
 def build_duels(raw: dict, players: PlayerDirectory, round_model: _RoundModel,

{cs2df-3.0.0 → cs2df-3.0.2}/src/cs2df/validate.py

@@ -24,6 +24,7 @@ EPS = 0.02
 # stream track columns that must all share length == frameCount
 _REPLAY_COLS = ("x", "y", "z", "yaw", "pitch", "hp", "armor", "money",
                 "equipValue", "weapon", "place", "flash", "flags")
+_REPLAY_OPTIONAL_FRAME_COLS = ("grenades",)
 _DUEL_COLS = ("x", "y", "z", "yaw", "pitch", "hp", "flash")
 _SHOT_COLS = ("tick", "weapon", "x", "y", "z", "vx", "vy", "vz", "yaw", "pitch")
 
@@ -374,6 +375,7 @@ def _check_replay_stream(replay: dict, n_players: int, round_set: set,
         for pi, track in enumerate(rd_obj.get("players", [])):
             tlabel = f"{label} players[{pi}]"
             _check_track_frames(tlabel, track, _REPLAY_COLS, fc, n_players, err)
+            _check_optional_track_frames(tlabel, track, _REPLAY_OPTIONAL_FRAME_COLS, fc, err)
             for w in track.get("weapon", []):
                 if w != -1 and not (0 <= w < len(wd)):
                     err(f"{tlabel}: weapon index {w} out of weaponDict range")
@@ -390,6 +392,12 @@ def _check_replay_stream(replay: dict, n_players: int, round_set: set,
                 err(f"{label} projectiles[{qi}]: throwerIndex out of range")
 
 
+def _check_optional_track_frames(label: str, track: dict, cols: tuple, frame_count: int, err) -> None:
+    bad = {c: len(track.get(c, [])) for c in cols if c in track and len(track.get(c, [])) != frame_count}
+    if bad:
+        err(f"{label}: optional column lengths != frameCount {frame_count}: {bad}")
+
+
 def _check_duels_stream(duels: dict, n_players: int, round_set: set,
                         rounds_by_number: dict, err):
     for wi, w in enumerate(duels.get("windows", [])):

{cs2df-3.0.0 → cs2df-3.0.2}/uv.lock

@@ -30,7 +30,7 @@ wheels = [
 
 [[package]]
 name = "cs2df"
-version = "3.0.0"
+version = "3.0.2"
 source = { editable = "." }
 dependencies = [
     { name = "demoparser2" },