Files
myrzx_bot/tools/compare_battle_v12.py
T

159 lines
8.7 KiB
Python

"""Compare local battle predictions with passively captured settlement requests.
Input and output are local files. No requests are sent or replayed.
"""
from collections import Counter
import argparse
import json
import math
from pathlib import Path
import statistics
OUTCOMES = frozenset(("battleService/battleEnd", "taskService/taskCompleteStep"))
CLIENT_VARIANTS = ("unknown", "original", "modified")
def observations(events):
pending, replies, notes, seen = {}, {}, Counter(), set()
for event in events:
operation = event.get("operation")
if operation not in OUTCOMES:
continue
key = (operation, str(event.get("request_id") or ""))
body = event.get("body")
if event.get("kind") == "request" and isinstance(body, dict) and isinstance(body.get("battleData"), dict):
if not key[1]:
notes["request_without_id"] += 1
continue
if key in pending:
notes["duplicate_request"] += 1
continue
pending[key] = event
elif event.get("kind") == "response" and isinstance(body, dict):
replies[key] = event
elif event.get("kind") == "error":
notes["capture_error"] += 1
samples = []
fields = ("win", "leftTime", "aliveNum", "apLeft", "killMonster", "killNum", "totalDamage", "deadNum", "bossDamage", "cheatNum")
for key, request in pending.items():
reply = replies.get(key)
if reply is None:
notes["settlement_response_missing"] += 1
continue
body = reply["body"]
if type(body.get("resCode")) is not int or body["resCode"] != 0:
notes["settlement_not_successful"] += 1
continue
battle = request["body"]["battleData"]
if (battle.get("win") is True and not battle.get("killMonster")
and all(battle.get(k, 0) == 0 for k in ("leftTime", "aliveNum", "apLeft", "killNum", "totalDamage", "deadNum", "bossDamage"))):
notes["sweep_or_ambiguous_empty_result"] += 1
continue
ids = battle.get("battleMonIds")
if not isinstance(ids, list) or any(type(mid) is not int or mid <= 0 for mid in ids):
notes["invalid_roster"] += 1
continue
position = battle.get("battlePosition")
if not isinstance(position, dict):
notes["position_missing"] += 1
continue
identity = (key[0], request["request_id"])
if identity in seen:
continue
seen.add(identity)
samples.append({"sample_id": request["request_id"], "operation": key[0], "time": request.get("time"),
"capture_origin": request.get("capture_origin", "unspecified"),
"position": {k: position.get(k) for k in ("battleType", "stageId", "stageLevel", "taskTypeId", "taskStep")},
"roster_instance_ids": ids,
"reported": {k: battle.get(k) for k in fields},
"response": {k: body.get(k) for k in ("costTi", "resCode")}})
for key in replies.keys() - pending.keys():
notes["response_without_settlement_request"] += 1
return samples, dict(notes)
def compare(estimate, sample, *, client_variant="unknown"):
if estimate.get("format") != "myrzx-offline-basic-attack-estimate":
raise ValueError("Not a supported estimate report")
if client_variant not in CLIENT_VARIANTS:
raise ValueError("Unknown client variant")
if client_variant == "modified":
return {"sample_id": sample["sample_id"], "status": "modified_client_not_calibratable"}
position, stage = sample["position"], estimate["stage"]
if position.get("battleType") != "stage":
return {"sample_id": sample["sample_id"], "status": "task_context_requires_separate_mapping"}
if str(position.get("stageId")) != str(stage["id"]) or str(position.get("stageLevel")) != str(stage["difficulty"]):
return {"sample_id": sample["sample_id"], "status": "different_stage_or_difficulty"}
supplied = [p.get("instance_id") for p in estimate.get("players", [])]
roster_matches = supplied == sample["roster_instance_ids"] if supplied and all(mid is not None for mid in supplied) else None
if roster_matches is False:
return {"sample_id": sample["sample_id"], "status": "different_roster"}
reported = sample["reported"]
limit, remaining = estimate.get("configured_time_limit_seconds"), reported.get("leftTime")
if (type(limit) not in (int, float) or type(remaining) not in (int, float)
or not math.isfinite(limit) or not math.isfinite(remaining)
or limit <= 0 or not 0 <= remaining <= limit * 1000 or type(reported.get("win")) is not bool):
return {"sample_id": sample["sample_id"], "status": "invalid_or_missing_timing"}
elapsed = limit - remaining / 1000
outcome = "win" if reported["win"] else "loss"
prediction = estimate.get("duration_seconds_by_predicted_outcome", {}).get(outcome)
status = ("exploratory_client_unverified" if client_variant == "unknown" else
"compared" if roster_matches else "exploratory_roster_unverified")
result = {"sample_id": sample["sample_id"], "status": status,
"observed_outcome": outcome, "observed_clock_elapsed_seconds": elapsed,
"roster_matches": roster_matches,
"same_attributes_and_resource_version_verified": False,
"model_has_samples_for_observed_outcome": prediction is not None}
if prediction:
delta = prediction["median"] - elapsed
result.update(model_median_seconds=prediction["median"], signed_time_error_seconds=delta,
absolute_time_error_seconds=abs(delta), relative_time_error=abs(delta) / elapsed if elapsed else None,
within_model_p10_p90=prediction["p10"] <= elapsed <= prediction["p90"])
return result
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--capture", type=Path, required=True, nargs="+")
parser.add_argument("--estimate", type=Path, help="Optional model report; omit to summarize protocol samples only")
parser.add_argument("--client-variant", choices=CLIENT_VARIANTS, default="unknown",
help="Operator-reported capture client, not independently verified")
parser.add_argument("--output", type=Path, required=True)
args = parser.parse_args(argv)
try:
events = []
for file in args.capture:
for line in file.read_text(encoding="utf-8").splitlines():
if line.strip():
event = json.loads(line)
if isinstance(event, dict):
events.append(event)
samples, diagnostics = observations(events)
estimate = json.loads(args.estimate.read_text(encoding="utf-8")) if args.estimate else None
comparisons = ([compare(estimate, sample, client_variant=args.client_variant) for sample in samples]
if estimate else [{"sample_id": sample["sample_id"], "status": "model_not_provided"} for sample in samples])
aligned = [row for row in comparisons if row["status"] == "compared"]
errors = [row["relative_time_error"] for row in aligned if row.get("relative_time_error") is not None]
report = {"format": "myrzx-local-battle-comparison", "version": 1,
"capture_client_variant": args.client_variant, "client_variant_source": "operator_report",
"accepted_settlement_sample_count": len(samples), "aligned_roster_comparison_count": len(aligned),
"median_relative_time_error": statistics.median(errors) if errors else None,
"diagnostics": diagnostics, "observations": samples, "comparisons": comparisons,
"limitations": ["Captured success validates that captured request, not a future simulated result.",
"Modified-client observations are protocol evidence, not original-damage calibration data.",
"Matching instance IDs do not verify identical attributes, equipment or hot-update resources.",
"Time uses configured battle limit minus reported leftTime in milliseconds, not HTTP wall time.",
"Samples and model intervals do not establish server verification rules."]}
args.output.parent.mkdir(parents=True, exist_ok=True)
args.output.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(json.dumps({k: report[k] for k in ("accepted_settlement_sample_count", "aligned_roster_comparison_count",
"median_relative_time_error", "diagnostics")}, ensure_ascii=True))
return 0
except (ValueError, TypeError, KeyError, OSError) as error:
print(json.dumps({"error": type(error).__name__, "message": str(error)}))
return 2
if __name__ == "__main__":
raise SystemExit(main())