Spaces:
Running on Zero
Running on Zero
| """Evolutions and pre-evolutions of existing dex species. | |
| The dex owns the chain rules (at most 3 stages, no cycles, legendaries | |
| neither evolve nor are evolved from - tools/dexlib.py there re-checks every | |
| submission at PR time), but a rejection that only arrives after the artwork | |
| is paid for is a bad experience. This module answers the two questions the | |
| Create tab must answer before spending anything: is this anchor allowed, and | |
| what family context does the new stage inherit? | |
| It reads the dex snapshot's species.json/spec.json directly, not the derived | |
| entries list: those are the files the dex validates, so the guard and the | |
| gatekeeper read the same fields. | |
| """ | |
| import json | |
| import os | |
| from fakemon_forge import species as species_mod | |
| MAX_CHAIN_LENGTH = 3 # mirrors tools/dexlib.py in the dex repo | |
| METHODS = { | |
| "Level up": "EVO_LEVEL", | |
| "Trade": "EVO_TRADE", | |
| "Friendship": "EVO_FRIENDSHIP", | |
| } | |
| def _load(path): | |
| try: | |
| with open(path) as f: | |
| return json.load(f) | |
| except (OSError, ValueError): | |
| return {} | |
| def chains(dex_root): | |
| """Per-species evolution context, keyed by directory slug. | |
| Each entry carries what the guard needs (links, legendary flags) and | |
| what the new stage inherits (family, family seed, stage position, the | |
| anchor's committed BST, its raw artwork for visual continuity). | |
| """ | |
| base = os.path.join(dex_root, "dex") | |
| out = {} | |
| if not os.path.isdir(base): | |
| return out | |
| for slug in sorted(os.listdir(base)): | |
| sdir = os.path.join(base, slug) | |
| if not os.path.isdir(sdir): | |
| continue | |
| spec = _load(os.path.join(sdir, "spec.json")) | |
| species = _load(os.path.join(sdir, "species.json")) | |
| if not spec and not species: | |
| continue | |
| targets = [l.get("target") for l in (species.get("evolvesTo") or []) | |
| if isinstance(l, dict) and l.get("target")] | |
| stats = [species.get(k) or 0 for k in | |
| ("baseHP", "baseAttack", "baseDefense", | |
| "baseSpAttack", "baseSpDefense", "baseSpeed")] | |
| out[slug] = { | |
| "name": spec.get("name") or species.get("speciesName") or slug, | |
| "family": spec.get("family") or slug, | |
| "family_seed": spec.get("family_seed", spec.get("seed", 0)), | |
| "stage": int(spec.get("stage") or 1), | |
| "of_stages": int(spec.get("of_stages") or 1), | |
| "from": species.get("evolvesFrom"), | |
| "to": targets, | |
| "legendary": bool(species.get("isSubLegendary") or | |
| species.get("isRestrictedLegendary")), | |
| "bst": sum(s for s in stats if isinstance(s, int)), | |
| "raw": os.path.join(sdir, "raw_front.png"), | |
| } | |
| return out | |
| def _back_len(ch, slug): | |
| """Stages before `slug` on its chain. Cycle-safe: corrupt data ends the walk.""" | |
| seen, n, total = set(), slug, 0 | |
| while True: | |
| prev = ch.get(n, {}).get("from") | |
| if not prev or prev in seen or prev not in ch: | |
| return total | |
| seen.add(prev) | |
| n, total = prev, total + 1 | |
| def _fwd_len(ch, slug): | |
| """Longest forward path from `slug`. Cycle-safe.""" | |
| best, stack = 0, [(slug, 0, {slug})] | |
| while stack: | |
| n, d, seen = stack.pop() | |
| best = max(best, d) | |
| for t in ch.get(n, {}).get("to", []): | |
| if t not in seen and t in ch: | |
| stack.append((t, d + 1, seen | {t})) | |
| return best | |
| def check_anchor(ch, anchor, direction): | |
| """None when the anchor may take this addition, else the reason it may not. | |
| direction is "evolution" (the new stage evolves from the anchor) or "pre" | |
| (the anchor evolves from the new stage). The dex re-checks all of this at | |
| PR time; this is the friendly front stop before paid generation. | |
| """ | |
| info = ch.get(anchor) | |
| if info is None: | |
| return f"Unknown anchor {anchor!r} - reload the dex and try again." | |
| name = info["name"] | |
| if info["legendary"]: | |
| return (f"{name} is legendary - legendaries cannot evolve or have " | |
| "pre-evolutions.") | |
| if direction == "pre": | |
| if info["from"]: | |
| return f"{name} already has a pre-evolution." | |
| if _fwd_len(ch, anchor) + 2 > MAX_CHAIN_LENGTH: | |
| return (f"A pre-evolution for {name} would make a chain longer " | |
| f"than {MAX_CHAIN_LENGTH}.") | |
| elif _back_len(ch, anchor) + 2 > MAX_CHAIN_LENGTH: | |
| return (f"{name} is already at the end of a {MAX_CHAIN_LENGTH}-stage " | |
| "chain.") | |
| return None | |
| def new_stage_context(ch, anchor, direction): | |
| """Family context and BST for the new stage. check_anchor() must pass first. | |
| The new stage joins the anchor's family: same family seed (so the battle | |
| style and stat-shape draws match the line), a stage position past the | |
| anchor - or before it, for a pre-evolution - and a BST drawn from the | |
| family's ladder as the rung it would occupy, clamped so an evolution is | |
| always an upgrade over the anchor's committed stats and a pre-evolution | |
| always a downgrade. The anchor's BST is real data; the re-drawn ladder is | |
| hypothetical, so the clamp wins ties. | |
| """ | |
| info = ch[anchor] | |
| seed_spec = {"family_seed": info["family_seed"]} | |
| if direction == "pre": | |
| stage = 1 | |
| of_stages = _fwd_len(ch, anchor) + 2 | |
| rung = species_mod.family_bst_ladder(seed_spec, of_stages)[0] | |
| total = max(species_mod.BST_STAGE_FLOOR, | |
| min(rung, info["bst"] - species_mod.BST_STAGE_GAP)) | |
| else: | |
| stage = info["stage"] + 1 | |
| of_stages = _back_len(ch, anchor) + 2 | |
| rung = species_mod.family_bst_ladder(seed_spec, stage)[-1] | |
| total = max(rung, info["bst"] + species_mod.BST_STAGE_GAP) | |
| # The legendary band is a ROM-level invariant; it outranks the upgrade gap | |
| # on the rare anchor whose committed BST sits right below it. | |
| total = min(total, species_mod.BST_LEGENDARY_MIN - 1) | |
| return {"family": info["family"], "family_seed": info["family_seed"], | |
| "stage": stage, "of_stages": of_stages, "total": total} | |