"""Known answers: what the Atlas knows about every answer the bot can be offered, for screens its other sources don't cover (issue #35). The bot looks the screen's choices up here first (solver.js `knownAnswer`), and passes what it finds to Clef as evidence when nothing is certain. python analysis/known/build_known.py [--check] -> data/public/known_answers.json Two sources, keyed by the answer text normalised exactly as the bot does (collection/etl/transform/bot.py normalize): guide every answer in the community route PDF's encounter trees (data/public/pdf_encounters.json): the encounter, how it ends there (or "continues"), the guide's rate, whether the guide marks it unconfirmed, and `on_path`: the colours whose recommended path in the guide goes through it bot every answer in the bot's screen tree (data/public/tree.json): times played, times it died straight after, and the bonds the runs that took it ended in """ import argparse import json import sys from pathlib import Path ROOT = Path(__file__).resolve().parents[2] sys.path.insert(0, str(ROOT)) from collection.etl.transform.bot import normalize # noqa: E402 GUIDE = ROOT / "data/public/pdf_encounters.json" TREE = ROOT / "data/public/tree.json" OUT = ROOT / "data/public/known_answers.json" # the colours each of the guide's encounters can end in a bond with (the two Greens can also end with an Orange or a # Brown swooping in), and the encounter a colour's route continues to from there (the shadow leads on to the Black) ENC_COLOURS = {"valley-Red": ["Red"], "tree-Red": ["Red"], "tree-Greens": ["Green", "Brown", "Orange"], "meadow-Orange": ["Orange"], "meadow-Brown": ["Brown"], "meadow-Blue": ["Blue"], "shadow": ["Black", "Blue"], "black": ["Black"]} ONWARD = {("shadow", "Black"): "Black"} def is_goal(end, colour, onward): end = end or "" if onward: return end.startswith(f"On to the {onward}") if not (end.startswith("Bonded") or "Bonded (" in end): return False return "(" not in end or colour in end def leads_to(o, colour, onward): if "end" in o: return is_goal(o["end"], colour, onward) return any(not c.get("roll") and leads_to(c, colour, onward) for c in o.get("then", [])) def guide_path(options, colour, onward): """The guide's recommended answers toward `colour` (the same walk as the page's encounter panel).""" out, opts = [], options while opts: live = [o for o in opts if not o.get("roll")] pick = next((o for o in live if o.get("best") and leads_to(o, colour, onward)), None) \ or next((o for o in live if leads_to(o, colour, onward)), None) if not pick: break out.append(id(pick)) if "end" in pick: break opts = pick.get("then", []) return out def walk(options, enc, on_path, out): """Every answer of an encounter, with its colours (where it happens) and on_path (whose recommended path).""" for o in options: if o.get("roll"): continue entry = {"encounter": enc, "colours": ENC_COLOURS.get(enc, []), "end": o.get("end", "continues")} if o.get("pct"): entry["pct"] = o["pct"] if o.get("best"): entry["best"] = True if o.get("unconfirmed"): entry["unconfirmed"] = True cols = sorted(c for c, ids in on_path.items() if id(o) in ids) if cols: entry["on_path"] = cols for text in [s.strip() for s in o["say"].split(", or ")]: # "Jump on its back, or jump to land…" out.setdefault(normalize(text), {"text": text, "guide": []})["guide"].append(entry) walk(o.get("then", []), enc, on_path, out) def build(): g = json.loads(GUIDE.read_text(encoding="utf-8")) out = {} for enc, E in g["encounters"].items(): on_path = {c: set(guide_path(E["options"], c, ONWARD.get((enc, c)))) for c in ENC_COLOURS.get(enc, [])} walk(E["options"], enc, on_path, out) t = json.loads(TREE.read_text(encoding="utf-8")) if TREE.exists() else {"screens": {}} for sc in t["screens"].values(): for o in sc["options"].values(): if not o.get("n"): continue k = normalize(o["text"]) e = out.setdefault(k, {"text": o["text"], "guide": []}) b = e.setdefault("bot", {"n": 0, "died": 0, "bonded": {}}) b["n"] += o["n"] for dest, d in o.get("to", {}).items(): if dest == "DIED": b["died"] += d["n"] elif dest.startswith("BONDED:"): c = dest.split(":", 1)[1] b["bonded"][c] = b["bonded"].get(c, 0) + d["n"] for e in out.values(): if not e["guide"]: del e["guide"] src = g["source"] return {"schema": 1, "guide": {"title": src["title"], "version": src["version"], "link": src["link"]}, "bot": {"runs": (t.get("builtFrom") or {}).get("runs")}, "answers": dict(sorted(out.items()))} def main(argv=None): ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("--check", action="store_true") a = ap.parse_args(argv) text = json.dumps(build(), ensure_ascii=False, indent=1) + "\n" if a.check: if not OUT.exists() or OUT.read_text(encoding="utf-8") != text: print(f"{OUT.relative_to(ROOT)} is out of date (run python analysis/known/build_known.py)", file=sys.stderr) return 1 return 0 OUT.write_text(text, encoding="utf-8") print(f"wrote {OUT.relative_to(ROOT)}") return 0 if __name__ == "__main__": sys.exit(main())