code/parse_logs.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
parse_logs.py —— EYBX 原始 JSONL → 紧凑 npz + 事件表

原始日志（每 session 一套，20 Hz）：
    boss深度日志.jsonl   type=meta / s(状态) / event(漫游事件)
    输入日志.jsonl       type=input（mv.deg / mv.mag / 按键）
    场景外观日志.jsonl   每次传送一行（= roam_scene 的副本）

产出 <out>/<session>/：
    state.npz    vt,x,y,z,yaw,hp,qf(Quantum帧号),rg(区域索引)   —— 逐条 20Hz 状态
    input.npz    vt,deg,mag,qf,keymask                          —— 逐条 20Hz 输入
    events.json  roam_leg_start / roam_leg_end / roam_scene / roam_leg_failed
    regions.json 区域名表（state.rg / events 里的索引）
    parse_report.json  行数、损坏行区间、vt 断档统计

损坏处理：日志里存在整段随机字节（体检报告里 20260823 的 vt 5118–5655）。这里
不猜不修，只按「JSON 解不出来」记为坏行，并把坏行前后仍能解出的 vt 记进报告，
由 budget 阶段按区间整体剔除。
"""
from __future__ import annotations

import argparse
import json
import os
import sys

import numpy as np

# 移动键 -> bit（keys 字段形如 "WD"）
KEYBITS = {"W": 1, "A": 2, "S": 4, "D": 8}


def keymask(s: str) -> int:
    m = 0
    for ch in s or "":
        m |= KEYBITS.get(ch.upper(), 0)
    return m


class RegionTable:
    """区域名 -> 稳定的整数索引（顺序即首次出现顺序）。"""

    def __init__(self):
        self.names: list[str] = []
        self._idx: dict[str, int] = {}

    def __call__(self, name) -> int:
        if name is None:
            name = ""
        i = self._idx.get(name)
        if i is None:
            i = len(self.names)
            self._idx[name] = i
            self.names.append(name)
        return i


def _iter_json(path: str):
    """逐行解析；产出 (行号, dict)，解不出来的行产出 (行号, None)。"""
    with open(path, "rb") as fh:
        for ln, raw in enumerate(fh):
            if not raw.strip():
                continue
            try:
                d = json.loads(raw)
            except Exception:
                yield ln, None
                continue
            # 损坏段是随机字节，其中个别行会恰好解成合法的 JSON 标量（裸数字/字符串）。
            # 只有 dict 才算好行，否则一样按坏行计。
            yield (ln, d) if isinstance(d, dict) else (ln, None)


def _bad_ranges(bad_lines: list[int]) -> list[list[int]]:
    """把连续坏行号压成 [start, end] 区间。"""
    out: list[list[int]] = []
    for ln in bad_lines:
        if out and ln == out[-1][1] + 1:
            out[-1][1] = ln
        else:
            out.append([ln, ln])
    return out


def parse_state(path: str, reg: RegionTable, progress_every: int = 500_000):
    vt, x, y, z, yaw, hp, qf, rg = ([] for _ in range(8))
    events: list[dict] = []
    meta: dict = {}
    bad: list[int] = []
    n = 0
    for ln, d in _iter_json(path):
        n += 1
        if progress_every and n % progress_every == 0:
            print(f"    ...{n:,} 行", flush=True)
        if d is None:
            bad.append(ln)
            continue
        t = d.get("type")
        if t == "s":
            # 只保留玩家实体；这批数据是 BOT 漫游，e 恒为 player，但不假设
            if d.get("e") not in (None, "player"):
                continue
            vt.append(d.get("vt", np.nan))
            x.append(d.get("x", np.nan))
            y.append(d.get("y", np.nan))
            z.append(d.get("z", np.nan))
            yaw.append(d.get("yaw", np.nan))
            hp.append(d.get("hp", np.nan))
            qf.append(d.get("f", -1))
            rg.append(reg(d.get("rg")))
        elif t == "event":
            e = dict(d)
            if "rg" in e:
                e["rg_idx"] = reg(e["rg"])
            events.append(e)
        elif t == "meta":
            meta = d
    arr = dict(
        vt=np.asarray(vt, np.float64),
        x=np.asarray(x, np.float32), y=np.asarray(y, np.float32), z=np.asarray(z, np.float32),
        yaw=np.asarray(yaw, np.float32), hp=np.asarray(hp, np.float32),
        qf=np.asarray(qf, np.int64), rg=np.asarray(rg, np.int32),
    )
    return arr, events, meta, bad, n


def parse_input(path: str, progress_every: int = 500_000):
    vt, deg, mag, qf, km = ([] for _ in range(5))
    bad: list[int] = []
    n = 0
    for ln, d in _iter_json(path):
        n += 1
        if progress_every and n % progress_every == 0:
            print(f"    ...{n:,} 行", flush=True)
        if d is None:
            bad.append(ln)
            continue
        if d.get("type") != "input":
            continue
        mv = d.get("mv") or {}
        vt.append(d.get("vt", np.nan))
        deg.append(mv.get("deg", np.nan))
        mag.append(mv.get("mag", np.nan))
        qf.append(d.get("f", -1))
        km.append(keymask(mv.get("keys", "")))
    arr = dict(
        vt=np.asarray(vt, np.float64),
        deg=np.asarray(deg, np.float32), mag=np.asarray(mag, np.float32),
        qf=np.asarray(qf, np.int64), keymask=np.asarray(km, np.uint8),
    )
    return arr, bad, n


def gap_stats(vt: np.ndarray, thresh: float = 1.0) -> dict:
    """>thresh 秒的采样断档：个数、总时长、最长。"""
    if vt.size < 2:
        return dict(n=0, total_s=0.0, max_s=0.0, ranges=[])
    d = np.diff(vt)
    idx = np.flatnonzero(d > thresh)
    ranges = [[float(vt[i]), float(vt[i + 1])] for i in idx]
    return dict(n=int(idx.size), total_s=float(d[idx].sum()) if idx.size else 0.0,
                max_s=float(d[idx].max()) if idx.size else 0.0, ranges=ranges)


def bad_vt_span(vt_all: np.ndarray, bad_ranges, line_to_vt) -> list[list[float]]:
    """把坏行区间映射成 vt 区间（用区间前后最近的好行的 vt 夹逼）。"""
    out = []
    for a, b in bad_ranges:
        lo = line_to_vt(a - 1)
        hi = line_to_vt(b + 1)
        if lo is not None and hi is not None:
            out.append([lo, hi])
    return out


def main():
    ap = argparse.ArgumentParser(description="EYBX 原始日志 → npz")
    ap.add_argument("--raw", default="/data/zhiyangdeng/EYBXROAM",
                    help="HF 下载根目录（含各 session 子目录）")
    ap.add_argument("--out", default="/data/zhiyangdeng/data_eybx/logs")
    ap.add_argument("--sessions", nargs="*", default=None, help="默认处理全部")
    args = ap.parse_args()

    sessions = args.sessions or sorted(
        d for d in os.listdir(args.raw)
        if os.path.isdir(os.path.join(args.raw, d)) and d[0].isdigit())
    if not sessions:
        sys.exit(f"[错误] {args.raw} 下没找到 session 目录")

    for sid in sessions:
        src = os.path.join(args.raw, sid)
        dst = os.path.join(args.out, sid)
        os.makedirs(dst, exist_ok=True)
        print(f"== {sid}")

        reg = RegionTable()

        print("  [1/3] boss深度日志.jsonl")
        st, events, meta, st_bad, st_lines = parse_state(
            os.path.join(src, "boss深度日志.jsonl"), reg)
        print(f"      状态 {st['vt'].size:,} 条 · 事件 {len(events):,} 条 · 坏行 {len(st_bad):,}")

        print("  [2/3] 输入日志.jsonl")
        ip, ip_bad, ip_lines = parse_input(os.path.join(src, "输入日志.jsonl"))
        print(f"      输入 {ip['vt'].size:,} 条 · 坏行 {len(ip_bad):,}")

        print("  [3/3] 写出")
        np.savez_compressed(os.path.join(dst, "state.npz"), **st)
        np.savez_compressed(os.path.join(dst, "input.npz"), **ip)
        with open(os.path.join(dst, "events.json"), "w", encoding="utf-8") as fh:
            json.dump(events, fh, ensure_ascii=False)
        with open(os.path.join(dst, "regions.json"), "w", encoding="utf-8") as fh:
            json.dump(reg.names, fh, ensure_ascii=False, indent=1)

        # 坏行 -> vt 区间：坏行不带 vt，用它前后仍可解析的行的 vt 夹逼。
        # 这里用一次轻量重扫，只取行号->vt 的映射（内存换准确）。
        def make_l2v(path, key="vt"):
            m: dict[int, float] = {}
            for ln, d in _iter_json(path):
                if d is not None and key in d:
                    m[ln] = float(d[key])
            return lambda ln: m.get(ln)

        st_spans = ip_spans = []
        if st_bad:
            st_spans = bad_vt_span(st["vt"], _bad_ranges(st_bad),
                                   make_l2v(os.path.join(src, "boss深度日志.jsonl")))
        if ip_bad:
            ip_spans = bad_vt_span(ip["vt"], _bad_ranges(ip_bad),
                                   make_l2v(os.path.join(src, "输入日志.jsonl")))

        ev_count: dict[str, int] = {}
        for e in events:
            ev_count[e.get("ev", "?")] = ev_count.get(e.get("ev", "?"), 0) + 1

        report = dict(
            session=sid, meta=meta,
            state=dict(lines=st_lines, kept=int(st["vt"].size), bad_lines=len(st_bad),
                       bad_vt_spans=st_spans, vt_range=[float(st["vt"].min()), float(st["vt"].max())],
                       gaps=gap_stats(st["vt"])),
            input=dict(lines=ip_lines, kept=int(ip["vt"].size), bad_lines=len(ip_bad),
                       bad_vt_spans=ip_spans, vt_range=[float(ip["vt"].min()), float(ip["vt"].max())],
                       gaps=gap_stats(ip["vt"])),
            events=ev_count, n_regions=len(reg.names),
        )
        with open(os.path.join(dst, "parse_report.json"), "w", encoding="utf-8") as fh:
            json.dump(report, fh, ensure_ascii=False, indent=1)

        g = report["state"]["gaps"]
        print(f"      vt {report['state']['vt_range'][0]:.1f}–{report['state']['vt_range'][1]:.1f} s"
              f" · >1s 断档 {g['n']} 处 / {g['total_s']/60:.1f} min / 最长 {g['max_s']:.1f} s")
        print(f"      事件 {ev_count} · 区域 {len(reg.names)} 个 -> {dst}")
    print("DONE")


if __name__ == "__main__":
    main()