Simplify replay

Author: john-b-yang

codeclash/arenas/battlesnake/replay.py

@@ -118,19 +118,3 @@ def parse(self, raw: bytes, players=None) -> ReplayData:
             draw=result.get("isDraw", False),
             extra={"colors": colors},
         )
-
-    def ascii(self, data: ReplayData) -> str:
-        out = []
-        for f in data.frames:
-            grid = [["." for _ in range(data.w)] for _ in range(data.h)]
-            for fx, fy in f["food"]:
-                grid[fy][fx] = "*"
-            for s in f["snakes"]:
-                ch = s["name"][0].upper()
-                for j, (x, y) in enumerate(s["body"]):
-                    grid[y][x] = ch if j else ch.lower()  # head lowercase-ish marker
-            out.append(f"\n--- turn {f['turn']} ---  " + "  ".join(f"{s['name']}:{s['health']}" for s in f["snakes"]))
-            for row in reversed(grid):  # y-up: print top row last
-                out.append(" ".join(row))
-        out.append(f"\nWinner: {'TIE' if data.draw else data.winner}")
-        return "\n".join(out)

codeclash/arenas/robotrumble/replay.py

@@ -155,27 +155,3 @@ def parse(self, raw: bytes, players=None) -> ReplayData:
                 "errors": data.get("errors", {}),
             },
         )
-
-    def ascii(self, data: ReplayData) -> str:
-        W, H = data.w, data.h
-        names = data.extra["names"]
-        wall_set = {(x, y) for x, y in data.extra["walls"]}
-        out = []
-        for f in data.frames:
-            grid = [["#" if (x, y) in wall_set else "." for x in range(W)] for y in range(H)]
-            for u in f["units"]:
-                grid[u["y"]][u["x"]] = "B" if u["team"] == "Blue" else "R"
-            counts = {"Blue": 0, "Red": 0}
-            hp = {"Blue": 0, "Red": 0}
-            for u in f["units"]:
-                counts[u["team"]] += 1
-                hp[u["team"]] += u["hp"]
-            out.append(
-                f"\n--- turn {f['turn']} ---  "
-                f"{names['Blue']}(B): {counts['Blue']} units / {hp['Blue']} hp   "
-                f"{names['Red']}(R): {counts['Red']} units / {hp['Red']} hp"
-            )
-            for row in grid:
-                out.append(" ".join(row))
-        out.append(f"\nWinner: {'TIE' if data.draw else data.winner}")
-        return "\n".join(out)

codeclash/cli/replay.py

@@ -1,52 +1,30 @@
-"""`codeclash replay` — turn a tournament log folder into browsable game playback.
+"""`codeclash replay` — serve a tournament folder and watch game replays in the browser.
 
 Points at a tournament folder (the one holding ``metadata.json`` + ``rounds/``); the arena
-is read from the metadata (or the folder name) and dispatched to its renderer. Games are
-discovered under ``rounds/`` (including ``round_<R>.tar.gz`` archives).
+is read from the metadata (or the folder name). Games are discovered under ``rounds/``
+(including ``round_<R>.tar.gz`` archives) and each replay is rendered on demand — nothing
+is written to disk.
 """
 
 from __future__ import annotations
 
-import webbrowser
 from pathlib import Path
 
 import typer
 
-from codeclash.replay import base, get_replayer, load_tournament
-
-# Cap on how many games `--all` will pre-generate before it stops and says so.
-ALL_CAP = 300
-
-
-def _bad(msg: str):
-    typer.echo(f"Error: {msg}", err=True)
-    raise typer.Exit(2)
+from codeclash.replay import get_replayer, load_tournament
+from codeclash.replay.serve import run_server
 
 
 def replay(
     folder: Path = typer.Argument(..., help="Tournament log folder (contains metadata.json + rounds/)."),
-    round: int | None = typer.Option(None, "--round", "-r", help="Round to replay (alone: every sim in the round)."),
-    sim: int | None = typer.Option(None, "--sim", "-s", help="Sim index (alone: that sim across every round)."),
-    all_games: bool = typer.Option(False, "--all", help="Pre-generate a playback page for every game."),
-    ascii_out: bool = typer.Option(False, "--ascii", help="Dump a single game to the terminal instead of HTML."),
-    open_browser: bool = typer.Option(False, "--open", "-o", help="Open the result in a browser when done."),
+    port: int = typer.Option(8000, "--port", "-p", help="Port to serve on (falls back to a free one if taken)."),
 ):
-    """Build a browsable replay site (index + on-demand per-game pages) for a tournament.
+    """Serve a tournament folder and lazily watch game replays in the browser.
 
-    [dim]• codeclash replay logs/<tournament-folder>          # build the browsable index[/dim]
-    [dim]• codeclash replay logs/<folder> -r 1 -s 0 --open    # one game, open in browser[/dim]
-    [dim]• codeclash replay logs/<folder> -r 1                # every sim in round 1[/dim]
-    [dim]• codeclash replay logs/<folder> --all              # pre-generate every game[/dim]
-    [dim]• codeclash replay logs/<folder> --ascii            # dump a game to the terminal[/dim]
+    [dim]• codeclash replay logs/<tournament-folder>[/dim]
+    [dim]• codeclash replay logs/<folder> -p 9000[/dim]
     """
-    # Reject contradictory modes up front, rather than silently picking one.
-    if ascii_out and all_games:
-        _bad("use either --ascii or --all, not both.")
-    if ascii_out and open_browser:
-        _bad("--ascii writes nothing to open; drop --open.")
-    if all_games and (round is not None or sim is not None):
-        _bad("--all replays every game — drop -r/-s (or omit --all to pick specific games).")
-
     tour = load_tournament(folder)
     renderer = get_replayer(tour.arena)
     if renderer is None:
@@ -55,74 +33,4 @@ def replay(
     if not tour.games:
         typer.echo(f"No sim files found under {folder} (looked for {renderer.sim_glob}).")
         raise typer.Exit(1)
-
-    def tour_payload(r: int, s: int) -> dict:
-        return {
-            "arena": tour.arena,
-            "players": tour.players,
-            "round": r,
-            "sim": s,
-            "round_winner": tour.round_winners.get(r),
-        }
-
-    def load(game):
-        return renderer.parse(base.read_sim(game), tour.players)
-
-    # ascii: a single game to the terminal, no files written.
-    if ascii_out:
-        g0 = tour.games[0]
-        r = round if round is not None else g0.round
-        s = sim if sim is not None else g0.sim
-        game = next((g for g in tour.games if g.round == r and g.sim == s), None)
-        if game is None:
-            typer.echo(f"No game at round {r}, sim {s}.")
-            raise typer.Exit(1)
-        typer.echo(renderer.ascii(load(game)))
-        return
-
-    # Which games to generate as HTML pages:
-    #   -r R -s S  -> that one game
-    #   -r R       -> every sim in round R
-    #   -s S       -> sim S across every round
-    #   --all      -> every game (capped)
-    #   (none)     -> index only
-    if all_games:
-        todo = tour.games[:ALL_CAP]
-    elif round is not None and sim is not None:
-        todo = [g for g in tour.games if g.round == round and g.sim == sim]
-    elif round is not None:
-        todo = [g for g in tour.games if g.round == round]
-    elif sim is not None:
-        todo = [g for g in tour.games if g.sim == sim]
-    else:
-        todo = []
-
-    if (round is not None or sim is not None) and not todo:
-        typer.echo(f"No games match round={round} sim={sim}. Run `codeclash replay {folder}` to list games.")
-        raise typer.Exit(1)
-
-    replay_dir = folder / "replay"
-    base.write_assets(replay_dir, renderer)
-    for g in todo:
-        (replay_dir / f"r{g.round}_s{g.sim}.html").write_text(
-            base.build_sim_stub(load(g), tour_payload(g.round, g.sim), renderer)
-        )
-    # Always (re)build the index so newly generated pages show as watchable.
-    index = replay_dir / "index.html"
-    index.write_text(base.build_index(tour, replay_dir))
-
-    if todo:
-        typer.echo(f"Generated {len(todo)} game page(s). Index: {index}")
-        if all_games and len(tour.games) > ALL_CAP:
-            typer.echo(f"Note: capped at {ALL_CAP} of {len(tour.games)} games — pass -r/-s for the rest.")
-    else:
-        typer.echo(f"Replay index: {index}")
-        typer.echo(f"{len(tour.games)} games found. Open a specific one with `-r <round> [-s <sim>]`.")
-
-    if open_browser:
-        # Open the single generated page if there's exactly one, else the index.
-        target = replay_dir / f"r{todo[0].round}_s{todo[0].sim}.html" if len(todo) == 1 else index
-        try:
-            webbrowser.open(target.resolve().as_uri())
-        except Exception:
-            typer.echo(f"(couldn't open a browser automatically — open {target} manually)")
+    run_server(folder, tour, renderer, port=port)

codeclash/replay/__init__.py

@@ -17,10 +17,9 @@
     ReplayRenderer,
     TournamentInfo,
     build_index,
-    build_sim_stub,
+    build_page,
     discover_games,
     read_sim,
-    write_assets,
 )
 
 __all__ = [
@@ -29,12 +28,11 @@
     "ReplayRenderer",
     "TournamentInfo",
     "build_index",
-    "build_sim_stub",
+    "build_page",
     "discover_games",
     "get_replayer",
     "load_tournament",
     "read_sim",
-    "write_assets",
 ]
 
 

codeclash/replay/base.py

@@ -91,10 +91,6 @@ class ReplayRenderer(ABC):
     def parse(self, raw: bytes, players: list[dict] | None = None) -> ReplayData:
         """Decode raw sim bytes into a :class:`ReplayData`. Input format is opaque."""
 
-    def ascii(self, data: ReplayData) -> str:
-        """Optional terminal rendering; arenas override."""
-        raise NotImplementedError(f"{self.arena} has no ascii renderer")
-
 
 # --------------------------------------------------------------------------------------
 # Sim discovery + reading
@@ -130,7 +126,7 @@ def discover_games(folder: Path, sim_glob: str) -> list[GameRef]:
                 archived.add(rnum)
                 with tarfile.open(entry) as tf:
                     for m in tf.getmembers():
-                        if m.isfile() and fnmatch.fnmatch(Path(m.name).name, sim_glob):
+                        if m.isfile() and m.size > 0 and fnmatch.fnmatch(Path(m.name).name, sim_glob):
                             games.append(
                                 GameRef(round=rnum, sim=_sim_index(Path(m.name).name), archive=entry, member=m.name)
                             )
@@ -140,11 +136,11 @@ def discover_games(folder: Path, sim_glob: str) -> list[GameRef]:
             if entry.is_dir() and _round_num(entry.name) not in archived:
                 rnum = _round_num(entry.name)
                 for f in sorted(entry.iterdir()):
-                    if f.is_file() and fnmatch.fnmatch(f.name, sim_glob):
+                    if f.is_file() and f.stat().st_size > 0 and fnmatch.fnmatch(f.name, sim_glob):
                         games.append(GameRef(round=rnum, sim=_sim_index(f.name), path=f))
     else:
         for f in sorted(folder.iterdir()):
-            if f.is_file() and fnmatch.fnmatch(f.name, sim_glob):
+            if f.is_file() and f.stat().st_size > 0 and fnmatch.fnmatch(f.name, sim_glob):
                 games.append(GameRef(round=0, sim=_sim_index(f.name), path=f))
     games.sort(key=lambda g: (g.round, g.sim))
     return games
@@ -279,49 +275,45 @@ def _doc(head_extra: str, scripts: str) -> str:
     )
 
 
-def build_sim_stub(data: ReplayData, tour: dict, renderer: ReplayRenderer) -> str:
-    """Thin per-sim page: inlines only this game's data, references shared assets."""
-    slug = renderer.arena.lower()
-    head = f'<title>{renderer.arena} replay</title><link rel="stylesheet" href="assets/replay.css">'
+def build_page(data: ReplayData, tour: dict, renderer: ReplayRenderer) -> str:
+    """A complete, self-contained replay page (CSS + player + arena JS + data inlined).
+
+    Built on demand by the server and served straight from memory — nothing is written to
+    disk.
+    """
+    head = f"<title>{renderer.arena} replay</title><style>{SHELL_CSS}{renderer.CSS}</style>"
     scripts = (
         "<script>window.G="
         + _script_safe(data.payload)
         + ";window.TOUR="
         + _script_safe(tour)
         + ";</script>\n"
-        + f'<script src="assets/{slug}.js"></script>\n'
-        + '<script src="assets/player.js"></script>'
+        + "<script>"
+        + renderer.DRAW_JS
+        + "</script>\n"
+        + "<script>"
+        + PLAYER_JS
+        + "</script>"
     )
     return _doc(head, scripts)
 
 
-def write_assets(replay_dir: Path, renderer: ReplayRenderer) -> None:
-    """Write the shared player assets once (idempotent)."""
-    adir = replay_dir / "assets"
-    adir.mkdir(parents=True, exist_ok=True)
-    (adir / "replay.css").write_text(SHELL_CSS + renderer.CSS)
-    (adir / "player.js").write_text(PLAYER_JS)
-    (adir / f"{renderer.arena.lower()}.js").write_text(renderer.DRAW_JS)
-
-
-def build_index(tour: TournamentInfo, replay_dir: Path) -> str:
-    """Index page listing every game (round x sim) with its winner and a watch link."""
+def build_index(tour: TournamentInfo) -> str:
+    """Index page: every game (round x sim) with its winner, linking to its replay."""
     players = " vs ".join(p["name"] for p in tour.players)
     rows = []
     for g in tour.games:
-        href = f"r{g.round}_s{g.sim}.html"
         winner = tour.round_winners.get(g.round, "")
-        if (replay_dir / href).exists():
-            cell = f'<a href="{href}">&#9654; watch</a>'
-        else:
-            cell = f'<span class="muted">not generated &mdash; <code>codeclash replay . -r {g.round} -s {g.sim}</code></span>'
+        cell = f'<a class="btn" href="game?r={g.round}&s={g.sim}">&#9654; watch</a>'
         rows.append(f"<tr><td>{g.round}</td><td>{g.sim}</td><td>{winner}</td><td>{cell}</td></tr>")
     style = (
         "body{background:#0d1117;color:#e6edf3;font:14px system-ui,sans-serif;margin:0;padding:24px}"
         "h1{font-size:18px}.muted{color:#8b949e}"
         "table{border-collapse:collapse;margin-top:12px}"
         "td,th{padding:6px 14px;border-bottom:1px solid #21262d;text-align:left}"
-        "a{color:#58a6ff}code{background:#161b22;padding:1px 5px;border-radius:4px}"
+        "a{color:#58a6ff}"
+        ".btn{display:inline-block;padding:3px 10px;border:1px solid #30363d;border-radius:6px;"
+        "background:#21262d;color:#e6edf3;text-decoration:none}.btn:hover{background:#30363d}"
     )
     header = (
         f"<h1>{tour.arena} &middot; {players}</h1>"