Diff gains a type_events axis keyed by (script type, event). The tracker lists each type's original events (vftable list, or the nearest class list up the constructor chain for Piklib 6.1) and where the emulator names them: the type's class, Variable.java or other engine code. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
164 lines
6.8 KiB
Python
164 lines
6.8 KiB
Python
"""Compute a structured diff between two engine-surface snapshots.
|
|
|
|
The result is a plain dict (JSON-serialisable). Each axis is a {added, removed, changed} block
|
|
produced by `keyed_diff`; `changed` entries carry the per-field old->new deltas. Methods also get
|
|
a cross-owner `moved` pass to surface hierarchy reparenting.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any, Callable, Hashable
|
|
|
|
from .snapshot import Snapshot
|
|
|
|
Item = dict
|
|
KeyFn = Callable[[Item], Hashable]
|
|
|
|
|
|
def _index(items: list[Item], key: KeyFn) -> dict[Hashable, Item]:
|
|
return {key(it): it for it in items}
|
|
|
|
|
|
def keyed_diff(a_items: list[Item], b_items: list[Item], key: KeyFn,
|
|
compare_fields: list[str]) -> dict[str, Any]:
|
|
"""Set-diff two item lists by `key`; for items present in both, report changed compare_fields."""
|
|
a = _index(a_items, key)
|
|
b = _index(b_items, key)
|
|
added = [b[k] for k in b if k not in a]
|
|
removed = [a[k] for k in a if k not in b]
|
|
changed = []
|
|
for k in a:
|
|
if k not in b:
|
|
continue
|
|
deltas = {f: [a[k].get(f), b[k].get(f)] for f in compare_fields if a[k].get(f) != b[k].get(f)}
|
|
if deltas:
|
|
changed.append({"item": b[k], "changes": deltas})
|
|
return {"added": added, "removed": removed, "changed": changed}
|
|
|
|
|
|
# --- per-axis keys -----------------------------------------------------------------------------
|
|
# Types: script_name + via_module_iface keeps the dual-dispatch MULTIARRAY entries distinct and
|
|
# stable across versions (addresses change, this semantic flag does not).
|
|
def _type_key(t: Item) -> Hashable:
|
|
return (t["script_name"], bool(t.get("via_module_iface")))
|
|
|
|
|
|
def _owner_name_key(x: Item) -> Hashable:
|
|
return (x["owner"], x["name"])
|
|
|
|
|
|
def _layout_key(x: Item) -> Hashable:
|
|
return (x["owner"], x["offset"])
|
|
|
|
|
|
def _detect_method_moves(old_m: list[Item], new_m: list[Item]) -> list[Item]:
|
|
"""A method name that left some owner and appeared under another - i.e. moved in the hierarchy."""
|
|
def owners_by_name(items: list[Item]) -> dict[str, set]:
|
|
out: dict[str, set] = {}
|
|
for m in items:
|
|
out.setdefault(m["name"], set()).add(m["owner"])
|
|
return out
|
|
|
|
old_o, new_o = owners_by_name(old_m), owners_by_name(new_m)
|
|
moves = []
|
|
for name in sorted(set(old_o) & set(new_o)):
|
|
lost = old_o[name] - new_o[name]
|
|
gained = new_o[name] - old_o[name]
|
|
if lost and gained:
|
|
moves.append({"name": name, "from_owners": sorted(lost), "to_owners": sorted(gained)})
|
|
return moves
|
|
|
|
|
|
def _dispatch_key(x: Item) -> Hashable:
|
|
return (x["owner"], x["id"])
|
|
|
|
|
|
def _dispatch_with_names(snap: Snapshot) -> list[Item]:
|
|
"""Attach the method name (from the methods axis, joined on owner+id) to each dispatch row,
|
|
so a body-level diff reads as 'SHOW body changed' rather than 'CMC_Animo id 1 changed'."""
|
|
name_by = {(m["owner"], m.get("id")): m["name"] for m in snap.methods}
|
|
out = []
|
|
for r in snap.method_dispatch:
|
|
rr = dict(r)
|
|
rr["name"] = name_by.get((r["owner"], r["id"]))
|
|
out.append(rr)
|
|
return out
|
|
|
|
|
|
def _dispatch_diff(old: Snapshot, new: Snapshot) -> dict[str, Any]:
|
|
"""Dispatch axis with body-level normalisation: every `changed` entry carries a `body`
|
|
{similarity, added, removed} from ams.normalize, and the block gets a `summary` measuring
|
|
how much the shared bodies changed overall (mean similarity, identical/changed counts)."""
|
|
from .normalize import body_delta, body_similarity
|
|
|
|
do = _dispatch_with_names(old)
|
|
dn = _dispatch_with_names(new)
|
|
block = keyed_diff(do, dn, _dispatch_key, ["impl", "calls"])
|
|
|
|
old_calls = {_dispatch_key(r): r.get("calls", []) for r in do}
|
|
new_calls = {_dispatch_key(r): r.get("calls", []) for r in dn}
|
|
for ch in block["changed"]:
|
|
k = _dispatch_key(ch["item"])
|
|
ch["body"] = body_delta(old_calls.get(k, []), new_calls.get(k, []))
|
|
|
|
shared = set(old_calls) & set(new_calls)
|
|
sims = [body_similarity(old_calls[k], new_calls[k]) for k in shared]
|
|
block["summary"] = {
|
|
"shared": len(shared),
|
|
"identical": sum(1 for s in sims if s == 100),
|
|
"changed": sum(1 for s in sims if s < 100),
|
|
"mean_similarity": int(round(sum(sims) / len(sims))) if sims else 100,
|
|
}
|
|
return block
|
|
|
|
|
|
def compute_diff(old: Snapshot, new: Snapshot) -> dict[str, Any]:
|
|
return {
|
|
"binary": {"from": old.binary, "to": new.binary},
|
|
"types": keyed_diff(old.types, new.types, _type_key, ["cpp_class", "object_size"]),
|
|
"methods": keyed_diff(old.methods, new.methods, _owner_name_key, ["id"]),
|
|
"events": keyed_diff(old.events, new.events, _owner_name_key, ["order"]),
|
|
"type_events": keyed_diff(old.type_events, new.type_events,
|
|
lambda x: (x["type"], x["name"]), ["order"]),
|
|
"fields": keyed_diff(old.fields, new.fields, _owner_name_key, ["type"]),
|
|
"struct_layout": keyed_diff(old.struct_layout, new.struct_layout, _layout_key,
|
|
["size", "is_vtable"]),
|
|
"method_dispatch": _dispatch_diff(old, new),
|
|
"method_inheritance": keyed_diff(old.method_inheritance, new.method_inheritance,
|
|
lambda x: x["runner"], ["base_runner"]),
|
|
"field_inheritance": keyed_diff(old.field_inheritance, new.field_inheritance,
|
|
lambda x: x["class"], ["base_class"]),
|
|
"moved_methods": _detect_method_moves(old.methods, new.methods),
|
|
}
|
|
|
|
|
|
# --- owner filtering (for `--owner CMC_Animo`) -------------------------------------------------
|
|
def _item_owner(axis: str, item: Item) -> str | None:
|
|
if axis == "types":
|
|
return item.get("cpp_class")
|
|
if axis in ("methods", "events", "fields", "struct_layout", "method_dispatch"):
|
|
return item.get("owner")
|
|
if axis == "type_events":
|
|
return item.get("type") # script type name, e.g. --owner ANIMO
|
|
if axis == "method_inheritance":
|
|
return item.get("runner")
|
|
if axis == "field_inheritance":
|
|
return item.get("class")
|
|
return None
|
|
|
|
|
|
def filter_by_owner(diff: dict[str, Any], owner: str) -> dict[str, Any]:
|
|
"""Restrict every axis to a single class/owner. `binary` and `moved_methods` are kept whole."""
|
|
out: dict[str, Any] = {"binary": diff["binary"]}
|
|
out["moved_methods"] = [m for m in diff["moved_methods"]
|
|
if owner in m["from_owners"] or owner in m["to_owners"]]
|
|
for axis, block in diff.items():
|
|
if axis in ("binary", "moved_methods"):
|
|
continue
|
|
out[axis] = {
|
|
"added": [i for i in block["added"] if _item_owner(axis, i) == owner],
|
|
"removed": [i for i in block["removed"] if _item_owner(axis, i) == owner],
|
|
"changed": [c for c in block["changed"] if _item_owner(axis, c["item"]) == owner],
|
|
}
|
|
return out
|