Datasets:

THUSI-Lab
/

Video-Arena

#!/usr/bin/env python3
"""cs2_judge.py — deterministic verifier for the CS2 three-tier task. Pure code,
no VLM/LLM judge. CS2 analog of tasks/go/judge.py.
Unlike the board games, CS2 needs no engine value function: every label is
objective ground truth read from the demo. The three tiers:
  T1 key-event localization : match answer events to GT on (round_no exact,
       type exact, |video_ts - gt_ts| <= tol) AND the type's entity attribute(s).
       round_no is part of the event's identity: miscounting one round shifts the
       round_no of every later event, and none of those can match (by design --
       counting rounds is part of reading the match):
         kill        -> victim colour (orange=T / blue=CT) + number (1-10 dot)
         bomb_planted-> planter colour
         conclusion  -> winner colour  (bomb_exploded/bomb_defused/elimination/save)
       A wrong number or wrong colour is NOT a match. Maximum 1-1, report P/R/F1.
       type in {kill, bomb_planted, bomb_defused, bomb_exploded, elimination, save}
       (save = 保枪 = time-expiry/target-saved). A GT attr of None is a wildcard.
  T2 current-round winner   : winner in {T, CT} per round. Report raw acc AND
       macro_acc (mean per-class recall over the classes PRESENT) — the
       shortcut-resistant headline (always-'T' collapses to <=0.5, oracle=1.0).
  T3 running match score    : REAL scoreboard by persistent team (A,B) across the
       halftime side-swap. Report exact-match frac over rounds AND final exact.
COUPLED answer format ( / board-game style — ONE unified event list; T2 and T3
are inlined onto every event and are round-constant, so all events in a round carry
the SAME round_winner + score_after):
  {"events":[{"round_no":1,"type":"kill","video_ts":3.4,"side":"CT","number":7,
                 "round_winner":"T","score_after":{"A":1,"B":0}}, ...]}
Primary reward = a SINGLE maximum 1:1 F1 over the full tuple
  (round_no, type, |Δt|<=tol, entity attrs, round_winner, score_after).
Any single wrong field — incl. the inlined round_winner (T2) or score_after (T3) —
voids the event, exactly like 's all-or-nothing full-tuple F1. The three-tier
breakdown (entity-only T1 F1, folded per-round T2/T3) is kept in `detail` for
transparency only and does NOT feed the reward.
Oracle self-check: `--oracle` feeds the GT itself as the answer; every tier must
score 1.0. An empty answer must score 0.0.
Usage:
    python cs2_judge.py --answer answer.json --gt gt.json [--tol 3.0] [--out reward.json]
    python cs2_judge.py --gt gt.json --oracle          # self-check (expect all 1.0)
"""
import argparse, heapq, json, sys
from collections import Counter, defaultdict

# colour/side aliases — the radar shows orange (T) vs blue (CT); accept either the
# colour the model reads off the video or the raw side token, EN or ZH.
WIN_ALIAS = {"T": "T", "TERRORIST": "T", "TERRORISTS": "T", "2": "T",
             "CT": "CT", "COUNTER-TERRORIST": "CT", "COUNTER-TERRORISTS": "CT", "3": "CT",
             "ORANGE": "T", "YELLOW": "T", "GOLD": "T", "橙": "T", "橙色": "T", "黄": "T",
             "黄色": "T", "T方": "T", "T队": "T",
             "BLUE": "CT", "蓝": "CT", "蓝色": "CT", "CT方": "CT", "CT队": "CT"}
TYPE_ALIAS = {"KILL": "kill", "DEATH": "kill", "FRAG": "kill",
              "死亡": "kill", "击杀": "kill", "阵亡": "kill",
              "BOMB_PLANTED": "bomb_planted", "PLANT": "bomb_planted",
              "PLANTED": "bomb_planted", "埋包": "bomb_planted", "下包": "bomb_planted",
              "安装炸弹": "bomb_planted", "安包": "bomb_planted",
              "BOMB_DEFUSED": "bomb_defused", "DEFUSE": "bomb_defused",
              "DEFUSED": "bomb_defused", "包拆": "bomb_defused", "拆包": "bomb_defused",
              "拆除": "bomb_defused", "拆弹": "bomb_defused",
              "BOMB_EXPLODED": "bomb_exploded", "EXPLODE": "bomb_exploded",
              "EXPLODED": "bomb_exploded", "DETONATE": "bomb_exploded",
              "包炸": "bomb_exploded", "爆炸": "bomb_exploded", "炸包": "bomb_exploded",
              "ELIMINATION": "elimination", "ELIM": "elimination", "WIPE": "elimination",
              "ACE": "elimination", "歼灭": "elimination", "团灭": "elimination",
              "SAVE": "save", "TIME": "save", "TIMEOUT": "save", "TARGET_SAVED": "save",
              "保枪": "save", "超时": "save"}


def nwin(w):
    return WIN_ALIAS.get(str(w).strip().upper(), str(w).strip().upper())


def ntype(t):
    return TYPE_ALIAS.get(str(t).strip().upper(), str(t).strip().lower())


def _color(d, keys):
    """First non-empty colour/side value among `keys`, normalized to T/CT (or None)."""
    for k in keys:
        v = d.get(k)
        if v is not None and str(v).strip() != "":
            return nwin(v)
    return None


def _num(x):
    """float for a number or numeric string; None otherwise (bool, NaN, inf too)."""
    if isinstance(x, bool):
        return None
    try:
        v = float(x)
    except (TypeError, ValueError):
        return None
    return v if abs(v) < 1e18 else None


def _round_no(x):
    """Integral round number (1, 1.0 or "1"); None for anything else."""
    v = _num(x)
    return int(v) if v is not None and v == int(v) else None


def _number(d):
    """Victim dot number (1-10) from an answer/GT event: prefer explicit 'number',
    else 'slot'+1 (slots are 0-9)."""
    if d.get("number") is not None:
        try:
            return int(d["number"])
        except (ValueError, TypeError, OverflowError):
            return None
    if d.get("slot") is not None:
        try:
            return int(d["slot"]) + 1
        except (ValueError, TypeError, OverflowError):
            return None
    return None


_COLOR_KEYS = ("side", "color", "colour", "team", "victim_side", "victim_color",
               "victim_colour", "planter_side", "planter_color", "winner_side",
               "winner_color", "winner")


def attr_ok(a, g):
    """Does answer event `a` carry the entity attribute(s) required by GT event `g`?
    A GT attribute of None acts as a wildcard (keeps the oracle at 1.0 when a rare
    parse could not resolve the victim)."""
    ty = ntype(g["type"])
    acol = _color(a, _COLOR_KEYS)
    if ty == "kill":
        gcol = nwin(g["side"]) if g.get("side") else None
        gnum = _number(g)
        anum = _number(a)
        col_ok = gcol is None or acol == gcol
        num_ok = gnum is None or (anum is not None and anum == gnum)
        return col_ok and num_ok
    if ty == "bomb_planted":
        gcol = nwin(g["side"]) if g.get("side") else None
        return gcol is None or acol == gcol
    # conclusion: bomb_exploded / bomb_defused / elimination / save -> winner colour
    gcol = nwin(g["winner_side"]) if g.get("winner_side") else None
    return gcol is None or acol == gcol


def _score_after(d):
    """Running scoreboard (A,B) inlined on an event, as an ordered pair or None."""
    sc = d.get("score_after")
    if isinstance(sc, dict) and sc.get("A") is not None and sc.get("B") is not None:
        try:
            return (int(sc["A"]), int(sc["B"]))
        except (ValueError, TypeError, OverflowError):
            return None
    # tolerate flat keys score_A / score_B
    if d.get("score_A") is not None and d.get("score_B") is not None:
        try:
            return (int(d["score_A"]), int(d["score_B"]))
        except (ValueError, TypeError, OverflowError):
            return None
    return None


def attr_ok_coupled(a, g):
    """-style COUPLED predicate: the entity attribute(s) AND the two inlined
    macro-state fields must all match — round_winner (T2) and score_after (T3).
    Any single wrong field (incl. winner or score) voids the event, so the three
    tiers are answered together inside one event tuple. GT None acts as wildcard."""
    if not attr_ok(a, g):
        return False
    # T2: round_winner (colour), read from `round_winner` ONLY -- falling back to
    # the entity colour (`side`, `winner_side`, ...) credited an answer that never
    # stated a round winner. GT None => wildcard.
    gw = nwin(g["round_winner"]) if g.get("round_winner") else None
    if gw is not None:
        aw = _color(a, ("round_winner",))
        if aw != gw:
            return False
    # T3: score_after (A,B) exact. GT None => wildcard.
    gs = _score_after(g)
    if gs is not None:
        if _score_after(a) != gs:
            return False
    return True


def _assign(cand, n_gt):
    """Maximum 1:1 matching of least total cost. cand[j] = [(cost, i), ...]: pred j may
    take GT row i at an integer cost. Successive shortest augmenting paths, searched
    from ALL free preds at once (Dijkstra on reduced costs), so the result has the most
    pairs and, of the matchings that large, the least total cost -- a pred never keeps
    a farther GT row just because it was looked at first. Returns owner[i] = the pred
    holding GT i, or -1."""
    P, INF = 1 + n_gt, float("inf")      # node ids: sink 0, GT row i 1+i, pred j P+j
    mate, owner = [-1] * len(cand), [-1] * n_gt
    price = [dict((i, c) for c, i in cs) for cs in cand]
    pot = [0] * (P + len(cand))
    while True:
        dist, prev = [INF] * len(pot), [-1] * len(pot)
        heap = [(0, P + j) for j in range(len(cand)) if mate[j] < 0 and cand[j]]
        for _, v in heap:                # sorted, so already a heap
            dist[v] = 0
        while heap:
            d, u = heapq.heappop(heap)
            if d > dist[u]:
                continue
            if u == 0:                   # the sink: the cheapest augmenting path
                break
            if u >= P:
                j = u - P
                steps = [(1 + i, c) for c, i in cand[j] if i != mate[j]]
            else:
                j = owner[u - 1]
                steps = [(P + j, -price[j][u - 1])] if j >= 0 else [(0, 0)]
            for v, c in steps:
                nd = d + c + pot[u] - pot[v]
                if nd < dist[v]:
                    dist[v], prev[v] = nd, u
                    heapq.heappush(heap, (nd, v))
        if dist[0] == INF:
            return owner
        for v in range(len(pot)):        # capped at the sink's distance: still feasible
            pot[v] += min(dist[v], dist[0])
        i = prev[0] - 1
        while i >= 0:
            j = prev[1 + i] - P
            nxt = mate[j]
            mate[j], owner[i] = i, j
            i = nxt


def _match(ans, gt, tol, pred):
    """Maximum 1:1 time-matched matching over (round_no, type, |dt|<=tol, pred).
    Takes the LARGEST set of disjoint (answer, GT) pairs, so row order cannot move
    the score; of the matchings that large it takes the least total |dt|, as every
    judge does. Answer rows are put in (time, content) order first, so the pairs are
    deterministic too. Returns the pair count."""
    rows = sorted((a for a in ans if _num(a.get("video_ts")) is not None),
                  key=lambda a: (_num(a["video_ts"]),
                                 json.dumps(a, sort_keys=True, default=str)))
    gts = [(e["round_no"], ntype(e["type"]), float(e["video_ts"]), e) for e in gt]
    cand = []
    for a in rows:
        art, aty = _round_no(a.get("round_no")), ntype(a.get("type"))
        ats = _num(a["video_ts"])
        cand.append([(round(abs(ats - gt_ts) * 1e6), gi)
                     for gi, (grn, gty, gt_ts, e) in enumerate(gts)
                     if grn == art and gty == aty and abs(ats - gt_ts) <= tol + 1e-9
                     and pred(a, e)])
    owner = _assign(cand, len(gts))
    return sum(1 for o in owner if o >= 0)


def _prf(matched, ans, gt):
    p = matched / len(ans) if ans else 0.0
    r = matched / len(gt) if gt else 0.0
    f1 = (2 * p * r / (p + r)) if (p + r) else 0.0
    return {"precision": round(p, 4), "recall": round(r, 4), "f1": round(f1, 4),
            "matched": matched, "n_ans": len(ans), "n_gt": len(gt)}


def score_unified(ans, gt, tol, pred=attr_ok_coupled):
    """Single maximum 1:1 time-matched F1 over the COUPLED event tuple
    (round_no, type, |Δt|<=tol, entity attrs, round_winner, score_after).
    Same matching core as score_t1 but the attribute predicate is injectable."""
    return _prf(_match(ans, gt, tol, pred), ans, gt)


def fold_rounds(events):
    """Collapse the inlined round_winner / score_after off a unified event list into
    per-round T2 / T3 views (the tiers are round-constant). If a round carries
    inconsistent values across its events, take the mode and flag the round."""
    win, score, seen = defaultdict(Counter), defaultdict(Counter), {}
    for e in events:
        rn = _round_no(e.get("round_no"))
        if rn is None:
            continue
        if e.get("round_winner") is not None:
            win[rn][nwin(e["round_winner"])] += 1
        sc = _score_after(e)
        if sc is not None:
            score[rn][sc] += 1
    inconsistent = sorted({rn for rn in win if len(win[rn]) > 1}
                          | {rn for rn in score if len(score[rn]) > 1})
    t2 = [{"round_no": rn, "winner": win[rn].most_common(1)[0][0]}
          for rn in sorted(win)]
    t3 = [{"round_no": rn, "A": score[rn].most_common(1)[0][0][0],
           "B": score[rn].most_common(1)[0][0][1]} for rn in sorted(score)]
    return t2, t3, inconsistent


def score_t1(ans, gt, tol):
    # entity-only: a wrong number / colour is still not a match
    return _prf(_match(ans, gt, tol, attr_ok), ans, gt)


def macro_acc(pairs):
    # pairs: list of (pred, gold); mean per-class recall over classes present in gold
    by = defaultdict(lambda: [0, 0])
    for pred, gold in pairs:
        by[gold][1] += 1
        if pred == gold:
            by[gold][0] += 1
    if not by:
        return 0.0
    return round(sum(c / n for c, n in by.values()) / len(by), 4)


def score_t2(ans, gt):
    gmap = {r["round_no"]: nwin(r["winner"]) for r in gt}
    amap = {a["round_no"]: nwin(a.get("winner")) for a in ans}
    pairs = [(amap.get(rn, "?"), w) for rn, w in gmap.items()]
    acc = round(sum(1 for p, g in pairs if p == g) / len(pairs), 4) if pairs else 0.0
    return {"acc": acc, "macro_acc": macro_acc(pairs), "n_rounds": len(gmap),
            "class_dist": dict(Counter(gmap.values()))}


def score_t3(ans, gt):
    # real team scoreboard (persistent team A vs B across the halftime side-swap)
    gmap = {r["round_no"]: (int(r["A"]), int(r["B"])) for r in gt}
    amap = {a["round_no"]: (int(a.get("A", -1)), int(a.get("B", -1))) for a in ans}
    exact = sum(1 for rn, sc in gmap.items() if amap.get(rn) == sc)
    frac = round(exact / len(gmap), 4) if gmap else 0.0
    final_rn = max(gmap) if gmap else None
    final_ok = amap.get(final_rn) == gmap.get(final_rn) if final_rn else False
    return {"exact_frac": frac, "exact": exact, "n_rounds": len(gmap),
            "final_score_exact": bool(final_ok)}


def evaluate(answer, gt, tol):
    """COUPLED (-style) reward: a single maximum 1:1 F1 over the full event tuple
    (round_no, type, |Δt|<=tol, entity attrs, round_winner, score_after). Any wrong
    field — incl. the inlined round_winner (T2) or score_after (T3) — voids the event.
    The three-tier decomposition is kept in `detail` for transparency only (it does
    NOT feed the reward): T1 = the entity-only F1 (score_t1); T2/T3 are FOLDED
    back out of the answer's inlined fields (fold_rounds) and scored per round."""
    ev = answer.get("events") if isinstance(answer, dict) else None
    ans_events = [e for e in ev if isinstance(e, dict)] if isinstance(ev, list) else []
    unified = score_unified(ans_events, gt["events"], tol)

    # --- transparency-only decomposition (not part of reward) ---
    t1 = score_t1(ans_events, gt["events"], tol)
    # T2/T3 come ONLY from the inlined event fields, so a diagnostic can never
    # report a T2 the scored events did not claim.
    a_t2, a_t3, incons = fold_rounds(ans_events)
    t2 = score_t2(a_t2, gt["t2_round_winners"])
    t3 = score_t3(a_t3, gt["t3_score_track"])

    return {"reward": unified["f1"], "unified": unified, "tol_s": tol,
            "detail": {"t1_localization": t1, "t2_round_winner": t2,
                       "t3_score_track": t3, "inconsistent_rounds": incons}}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--gt", required=True)
    ap.add_argument("--answer")
    ap.add_argument("--tol", type=float, default=3.0)
    ap.add_argument("--oracle", action="store_true")
    ap.add_argument("--out")
    args = ap.parse_args()
    gt = json.load(open(args.gt, encoding="utf-8"))

    if args.oracle:
        # coupling invariant: within each round every inlined event carries the SAME
        # round_winner + score_after (GT is built that way; assert to catch regressions)
        by_r = defaultdict(set)
        for e in gt["events"]:
            by_r[e["round_no"]].add((e.get("round_winner"),
                                     tuple(sorted((e.get("score_after") or {}).items()))))
        bad = {rn: v for rn, v in by_r.items() if len(v) > 1}
        # oracle answer = GT's own inlined event list (T2/T3 fold out of it)
        oracle_ans = {"events": gt["events"]}
        r_ok = evaluate(oracle_ans, gt, args.tol)
        r_empty = evaluate({}, gt, args.tol)
        det = r_ok["detail"]
        ok = (not bad and r_ok["reward"] == 1.0 and r_ok["unified"]["f1"] == 1.0
              and det["t1_localization"]["f1"] == 1.0
              and det["t2_round_winner"]["macro_acc"] == 1.0
              and det["t3_score_track"]["exact_frac"] == 1.0
              and not det["inconsistent_rounds"] and r_empty["reward"] == 0.0)
        print(f"ORACLE unified_f1={r_ok['reward']} "
              f"(decomp t1_f1={det['t1_localization']['f1']} "
              f"t2_macro={det['t2_round_winner']['macro_acc']} "
              f"t3_exact={det['t3_score_track']['exact_frac']})  "
              f"invariant={'ok' if not bad else f'VIOLATED {bad}'}  "
              f"EMPTY reward={r_empty['reward']}  -> {'PASS' if ok else 'FAIL'}")
        raise SystemExit(0 if ok else 1)

    # A malformed answer (BOM, bare list, null, non-dict rows) scores, never crashes:
    # a crash would turn the cell into "judge failed" and drop it from the mean.
    try:
        with open(args.answer, encoding="utf-8-sig") as f:
            answer = json.load(f)
    except Exception as e:
        print(f"answer unreadable ({e}) -> 0", file=sys.stderr)
        answer = {}
    if isinstance(answer, list):
        answer = {"events": answer}
    res = evaluate(answer, gt, args.tol)
    if args.out:
        json.dump(res, open(args.out, "w", encoding="utf-8"), ensure_ascii=False, indent=2)
    print(json.dumps(res, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""cs2_judge.py — deterministic verifier for the CS2 three-tier task. Pure code,
	no VLM/LLM judge. CS2 analog of tasks/go/judge.py.

	Unlike the board games, CS2 needs no engine value function: every label is
	objective ground truth read from the demo. The three tiers:

	T1 key-event localization : match answer events to GT on (round_no exact,
	type exact, \|video_ts - gt_ts\| <= tol) AND the type's entity attribute(s).
	round_no is part of the event's identity: miscounting one round shifts the
	round_no of every later event, and none of those can match (by design --
	counting rounds is part of reading the match):
	kill -> victim colour (orange=T / blue=CT) + number (1-10 dot)
	bomb_planted-> planter colour
	conclusion -> winner colour (bomb_exploded/bomb_defused/elimination/save)
	A wrong number or wrong colour is NOT a match. Maximum 1-1, report P/R/F1.
	type in {kill, bomb_planted, bomb_defused, bomb_exploded, elimination, save}
	(save = 保枪 = time-expiry/target-saved). A GT attr of None is a wildcard.
	T2 current-round winner : winner in {T, CT} per round. Report raw acc AND
	macro_acc (mean per-class recall over the classes PRESENT) — the
	shortcut-resistant headline (always-'T' collapses to <=0.5, oracle=1.0).
	T3 running match score : REAL scoreboard by persistent team (A,B) across the
	halftime side-swap. Report exact-match frac over rounds AND final exact.

	COUPLED answer format ( / board-game style — ONE unified event list; T2 and T3
	are inlined onto every event and are round-constant, so all events in a round carry
	the SAME round_winner + score_after):
	{"events":[{"round_no":1,"type":"kill","video_ts":3.4,"side":"CT","number":7,
	"round_winner":"T","score_after":{"A":1,"B":0}}, ...]}

	Primary reward = a SINGLE maximum 1:1 F1 over the full tuple
	(round_no, type, \|Δt\|<=tol, entity attrs, round_winner, score_after).
	Any single wrong field — incl. the inlined round_winner (T2) or score_after (T3) —
	voids the event, exactly like 's all-or-nothing full-tuple F1. The three-tier
	breakdown (entity-only T1 F1, folded per-round T2/T3) is kept in `detail` for
	transparency only and does NOT feed the reward.

	Oracle self-check: `--oracle` feeds the GT itself as the answer; every tier must
	score 1.0. An empty answer must score 0.0.

	Usage:
	python cs2_judge.py --answer answer.json --gt gt.json [--tol 3.0] [--out reward.json]
	python cs2_judge.py --gt gt.json --oracle # self-check (expect all 1.0)
	"""
	import argparse, heapq, json, sys
	from collections import Counter, defaultdict

	# colour/side aliases — the radar shows orange (T) vs blue (CT); accept either the
	# colour the model reads off the video or the raw side token, EN or ZH.
	WIN_ALIAS = {"T": "T", "TERRORIST": "T", "TERRORISTS": "T", "2": "T",
	"CT": "CT", "COUNTER-TERRORIST": "CT", "COUNTER-TERRORISTS": "CT", "3": "CT",
	"ORANGE": "T", "YELLOW": "T", "GOLD": "T", "橙": "T", "橙色": "T", "黄": "T",
	"黄色": "T", "T方": "T", "T队": "T",
	"BLUE": "CT", "蓝": "CT", "蓝色": "CT", "CT方": "CT", "CT队": "CT"}
	TYPE_ALIAS = {"KILL": "kill", "DEATH": "kill", "FRAG": "kill",
	"死亡": "kill", "击杀": "kill", "阵亡": "kill",
	"BOMB_PLANTED": "bomb_planted", "PLANT": "bomb_planted",
	"PLANTED": "bomb_planted", "埋包": "bomb_planted", "下包": "bomb_planted",
	"安装炸弹": "bomb_planted", "安包": "bomb_planted",
	"BOMB_DEFUSED": "bomb_defused", "DEFUSE": "bomb_defused",
	"DEFUSED": "bomb_defused", "包拆": "bomb_defused", "拆包": "bomb_defused",
	"拆除": "bomb_defused", "拆弹": "bomb_defused",
	"BOMB_EXPLODED": "bomb_exploded", "EXPLODE": "bomb_exploded",
	"EXPLODED": "bomb_exploded", "DETONATE": "bomb_exploded",
	"包炸": "bomb_exploded", "爆炸": "bomb_exploded", "炸包": "bomb_exploded",
	"ELIMINATION": "elimination", "ELIM": "elimination", "WIPE": "elimination",
	"ACE": "elimination", "歼灭": "elimination", "团灭": "elimination",
	"SAVE": "save", "TIME": "save", "TIMEOUT": "save", "TARGET_SAVED": "save",
	"保枪": "save", "超时": "save"}


	def nwin(w):
	return WIN_ALIAS.get(str(w).strip().upper(), str(w).strip().upper())


	def ntype(t):
	return TYPE_ALIAS.get(str(t).strip().upper(), str(t).strip().lower())


	def _color(d, keys):
	"""First non-empty colour/side value among `keys`, normalized to T/CT (or None)."""
	for k in keys:
	v = d.get(k)
	if v is not None and str(v).strip() != "":
	return nwin(v)
	return None


	def _num(x):
	"""float for a number or numeric string; None otherwise (bool, NaN, inf too)."""
	if isinstance(x, bool):
	return None
	try:
	v = float(x)
	except (TypeError, ValueError):
	return None
	return v if abs(v) < 1e18 else None


	def _round_no(x):
	"""Integral round number (1, 1.0 or "1"); None for anything else."""
	v = _num(x)
	return int(v) if v is not None and v == int(v) else None


	def _number(d):
	"""Victim dot number (1-10) from an answer/GT event: prefer explicit 'number',
	else 'slot'+1 (slots are 0-9)."""
	if d.get("number") is not None:
	try:
	return int(d["number"])
	except (ValueError, TypeError, OverflowError):
	return None
	if d.get("slot") is not None:
	try:
	return int(d["slot"]) + 1
	except (ValueError, TypeError, OverflowError):
	return None
	return None


	_COLOR_KEYS = ("side", "color", "colour", "team", "victim_side", "victim_color",
	"victim_colour", "planter_side", "planter_color", "winner_side",
	"winner_color", "winner")


	def attr_ok(a, g):
	"""Does answer event `a` carry the entity attribute(s) required by GT event `g`?
	A GT attribute of None acts as a wildcard (keeps the oracle at 1.0 when a rare
	parse could not resolve the victim)."""
	ty = ntype(g["type"])
	acol = _color(a, _COLOR_KEYS)
	if ty == "kill":
	gcol = nwin(g["side"]) if g.get("side") else None
	gnum = _number(g)
	anum = _number(a)
	col_ok = gcol is None or acol == gcol
	num_ok = gnum is None or (anum is not None and anum == gnum)
	return col_ok and num_ok
	if ty == "bomb_planted":
	gcol = nwin(g["side"]) if g.get("side") else None
	return gcol is None or acol == gcol
	# conclusion: bomb_exploded / bomb_defused / elimination / save -> winner colour
	gcol = nwin(g["winner_side"]) if g.get("winner_side") else None
	return gcol is None or acol == gcol


	def _score_after(d):
	"""Running scoreboard (A,B) inlined on an event, as an ordered pair or None."""
	sc = d.get("score_after")
	if isinstance(sc, dict) and sc.get("A") is not None and sc.get("B") is not None:
	try:
	return (int(sc["A"]), int(sc["B"]))
	except (ValueError, TypeError, OverflowError):
	return None
	# tolerate flat keys score_A / score_B
	if d.get("score_A") is not None and d.get("score_B") is not None:
	try:
	return (int(d["score_A"]), int(d["score_B"]))
	except (ValueError, TypeError, OverflowError):
	return None
	return None


	def attr_ok_coupled(a, g):
	"""-style COUPLED predicate: the entity attribute(s) AND the two inlined
	macro-state fields must all match — round_winner (T2) and score_after (T3).
	Any single wrong field (incl. winner or score) voids the event, so the three
	tiers are answered together inside one event tuple. GT None acts as wildcard."""
	if not attr_ok(a, g):
	return False
	# T2: round_winner (colour), read from `round_winner` ONLY -- falling back to
	# the entity colour (`side`, `winner_side`, ...) credited an answer that never
	# stated a round winner. GT None => wildcard.
	gw = nwin(g["round_winner"]) if g.get("round_winner") else None
	if gw is not None:
	aw = _color(a, ("round_winner",))
	if aw != gw:
	return False
	# T3: score_after (A,B) exact. GT None => wildcard.
	gs = _score_after(g)
	if gs is not None:
	if _score_after(a) != gs:
	return False
	return True


	def _assign(cand, n_gt):
	"""Maximum 1:1 matching of least total cost. cand[j] = [(cost, i), ...]: pred j may
	take GT row i at an integer cost. Successive shortest augmenting paths, searched
	from ALL free preds at once (Dijkstra on reduced costs), so the result has the most
	pairs and, of the matchings that large, the least total cost -- a pred never keeps
	a farther GT row just because it was looked at first. Returns owner[i] = the pred
	holding GT i, or -1."""
	P, INF = 1 + n_gt, float("inf") # node ids: sink 0, GT row i 1+i, pred j P+j
	mate, owner = [-1] * len(cand), [-1] * n_gt
	price = [dict((i, c) for c, i in cs) for cs in cand]
	pot = [0] * (P + len(cand))
	while True:
	dist, prev = [INF] * len(pot), [-1] * len(pot)
	heap = [(0, P + j) for j in range(len(cand)) if mate[j] < 0 and cand[j]]
	for _, v in heap: # sorted, so already a heap
	dist[v] = 0
	while heap:
	d, u = heapq.heappop(heap)
	if d > dist[u]:
	continue
	if u == 0: # the sink: the cheapest augmenting path
	break
	if u >= P:
	j = u - P
	steps = [(1 + i, c) for c, i in cand[j] if i != mate[j]]
	else:
	j = owner[u - 1]
	steps = [(P + j, -price[j][u - 1])] if j >= 0 else [(0, 0)]
	for v, c in steps:
	nd = d + c + pot[u] - pot[v]
	if nd < dist[v]:
	dist[v], prev[v] = nd, u
	heapq.heappush(heap, (nd, v))
	if dist[0] == INF:
	return owner
	for v in range(len(pot)): # capped at the sink's distance: still feasible
	pot[v] += min(dist[v], dist[0])
	i = prev[0] - 1
	while i >= 0:
	j = prev[1 + i] - P
	nxt = mate[j]
	mate[j], owner[i] = i, j
	i = nxt


	def _match(ans, gt, tol, pred):
	"""Maximum 1:1 time-matched matching over (round_no, type, \|dt\|<=tol, pred).
	Takes the LARGEST set of disjoint (answer, GT) pairs, so row order cannot move
	the score; of the matchings that large it takes the least total \|dt\|, as every
	judge does. Answer rows are put in (time, content) order first, so the pairs are
	deterministic too. Returns the pair count."""
	rows = sorted((a for a in ans if _num(a.get("video_ts")) is not None),
	key=lambda a: (_num(a["video_ts"]),
	json.dumps(a, sort_keys=True, default=str)))
	gts = [(e["round_no"], ntype(e["type"]), float(e["video_ts"]), e) for e in gt]
	cand = []
	for a in rows:
	art, aty = _round_no(a.get("round_no")), ntype(a.get("type"))
	ats = _num(a["video_ts"])
	cand.append([(round(abs(ats - gt_ts) * 1e6), gi)
	for gi, (grn, gty, gt_ts, e) in enumerate(gts)
	if grn == art and gty == aty and abs(ats - gt_ts) <= tol + 1e-9
	and pred(a, e)])
	owner = _assign(cand, len(gts))
	return sum(1 for o in owner if o >= 0)


	def _prf(matched, ans, gt):
	p = matched / len(ans) if ans else 0.0
	r = matched / len(gt) if gt else 0.0
	f1 = (2 * p * r / (p + r)) if (p + r) else 0.0
	return {"precision": round(p, 4), "recall": round(r, 4), "f1": round(f1, 4),
	"matched": matched, "n_ans": len(ans), "n_gt": len(gt)}


	def score_unified(ans, gt, tol, pred=attr_ok_coupled):
	"""Single maximum 1:1 time-matched F1 over the COUPLED event tuple
	(round_no, type, \|Δt\|<=tol, entity attrs, round_winner, score_after).
	Same matching core as score_t1 but the attribute predicate is injectable."""
	return _prf(_match(ans, gt, tol, pred), ans, gt)


	def fold_rounds(events):
	"""Collapse the inlined round_winner / score_after off a unified event list into
	per-round T2 / T3 views (the tiers are round-constant). If a round carries
	inconsistent values across its events, take the mode and flag the round."""
	win, score, seen = defaultdict(Counter), defaultdict(Counter), {}
	for e in events:
	rn = _round_no(e.get("round_no"))
	if rn is None:
	continue
	if e.get("round_winner") is not None:
	win[rn][nwin(e["round_winner"])] += 1
	sc = _score_after(e)
	if sc is not None:
	score[rn][sc] += 1
	inconsistent = sorted({rn for rn in win if len(win[rn]) > 1}
	\| {rn for rn in score if len(score[rn]) > 1})
	t2 = [{"round_no": rn, "winner": win[rn].most_common(1)[0][0]}
	for rn in sorted(win)]
	t3 = [{"round_no": rn, "A": score[rn].most_common(1)[0][0][0],
	"B": score[rn].most_common(1)[0][0][1]} for rn in sorted(score)]
	return t2, t3, inconsistent


	def score_t1(ans, gt, tol):
	# entity-only: a wrong number / colour is still not a match
	return _prf(_match(ans, gt, tol, attr_ok), ans, gt)


	def macro_acc(pairs):
	# pairs: list of (pred, gold); mean per-class recall over classes present in gold
	by = defaultdict(lambda: [0, 0])
	for pred, gold in pairs:
	by[gold][1] += 1
	if pred == gold:
	by[gold][0] += 1
	if not by:
	return 0.0
	return round(sum(c / n for c, n in by.values()) / len(by), 4)


	def score_t2(ans, gt):
	gmap = {r["round_no"]: nwin(r["winner"]) for r in gt}
	amap = {a["round_no"]: nwin(a.get("winner")) for a in ans}
	pairs = [(amap.get(rn, "?"), w) for rn, w in gmap.items()]
	acc = round(sum(1 for p, g in pairs if p == g) / len(pairs), 4) if pairs else 0.0
	return {"acc": acc, "macro_acc": macro_acc(pairs), "n_rounds": len(gmap),
	"class_dist": dict(Counter(gmap.values()))}


	def score_t3(ans, gt):
	# real team scoreboard (persistent team A vs B across the halftime side-swap)
	gmap = {r["round_no"]: (int(r["A"]), int(r["B"])) for r in gt}
	amap = {a["round_no"]: (int(a.get("A", -1)), int(a.get("B", -1))) for a in ans}
	exact = sum(1 for rn, sc in gmap.items() if amap.get(rn) == sc)
	frac = round(exact / len(gmap), 4) if gmap else 0.0
	final_rn = max(gmap) if gmap else None
	final_ok = amap.get(final_rn) == gmap.get(final_rn) if final_rn else False
	return {"exact_frac": frac, "exact": exact, "n_rounds": len(gmap),
	"final_score_exact": bool(final_ok)}


	def evaluate(answer, gt, tol):
	"""COUPLED (-style) reward: a single maximum 1:1 F1 over the full event tuple
	(round_no, type, \|Δt\|<=tol, entity attrs, round_winner, score_after). Any wrong
	field — incl. the inlined round_winner (T2) or score_after (T3) — voids the event.

	The three-tier decomposition is kept in `detail` for transparency only (it does
	NOT feed the reward): T1 = the entity-only F1 (score_t1); T2/T3 are FOLDED
	back out of the answer's inlined fields (fold_rounds) and scored per round."""
	ev = answer.get("events") if isinstance(answer, dict) else None
	ans_events = [e for e in ev if isinstance(e, dict)] if isinstance(ev, list) else []
	unified = score_unified(ans_events, gt["events"], tol)

	# --- transparency-only decomposition (not part of reward) ---
	t1 = score_t1(ans_events, gt["events"], tol)
	# T2/T3 come ONLY from the inlined event fields, so a diagnostic can never
	# report a T2 the scored events did not claim.
	a_t2, a_t3, incons = fold_rounds(ans_events)
	t2 = score_t2(a_t2, gt["t2_round_winners"])
	t3 = score_t3(a_t3, gt["t3_score_track"])

	return {"reward": unified["f1"], "unified": unified, "tol_s": tol,
	"detail": {"t1_localization": t1, "t2_round_winner": t2,
	"t3_score_track": t3, "inconsistent_rounds": incons}}


	def main():
	ap = argparse.ArgumentParser()
	ap.add_argument("--gt", required=True)
	ap.add_argument("--answer")
	ap.add_argument("--tol", type=float, default=3.0)
	ap.add_argument("--oracle", action="store_true")
	ap.add_argument("--out")
	args = ap.parse_args()
	gt = json.load(open(args.gt, encoding="utf-8"))

	if args.oracle:
	# coupling invariant: within each round every inlined event carries the SAME
	# round_winner + score_after (GT is built that way; assert to catch regressions)
	by_r = defaultdict(set)
	for e in gt["events"]:
	by_r[e["round_no"]].add((e.get("round_winner"),
	tuple(sorted((e.get("score_after") or {}).items()))))
	bad = {rn: v for rn, v in by_r.items() if len(v) > 1}
	# oracle answer = GT's own inlined event list (T2/T3 fold out of it)
	oracle_ans = {"events": gt["events"]}
	r_ok = evaluate(oracle_ans, gt, args.tol)
	r_empty = evaluate({}, gt, args.tol)
	det = r_ok["detail"]
	ok = (not bad and r_ok["reward"] == 1.0 and r_ok["unified"]["f1"] == 1.0
	and det["t1_localization"]["f1"] == 1.0
	and det["t2_round_winner"]["macro_acc"] == 1.0
	and det["t3_score_track"]["exact_frac"] == 1.0
	and not det["inconsistent_rounds"] and r_empty["reward"] == 0.0)
	print(f"ORACLE unified_f1={r_ok['reward']} "
	f"(decomp t1_f1={det['t1_localization']['f1']} "
	f"t2_macro={det['t2_round_winner']['macro_acc']} "
	f"t3_exact={det['t3_score_track']['exact_frac']}) "
	f"invariant={'ok' if not bad else f'VIOLATED {bad}'} "
	f"EMPTY reward={r_empty['reward']} -> {'PASS' if ok else 'FAIL'}")
	raise SystemExit(0 if ok else 1)

	# A malformed answer (BOM, bare list, null, non-dict rows) scores, never crashes:
	# a crash would turn the cell into "judge failed" and drop it from the mean.
	try:
	with open(args.answer, encoding="utf-8-sig") as f:
	answer = json.load(f)
	except Exception as e:
	print(f"answer unreadable ({e}) -> 0", file=sys.stderr)
	answer = {}
	if isinstance(answer, list):
	answer = {"events": answer}
	res = evaluate(answer, gt, args.tol)
	if args.out:
	json.dump(res, open(args.out, "w", encoding="utf-8"), ensure_ascii=False, indent=2)
	print(json.dumps(res, ensure_ascii=False, indent=2))


	if __name__ == "__main__":
	main()