harness.py

Part of Tiny Yurts.

"""Scripted-input harness for Tiny Yurts.

Captures key gameplay stages:

  01_menu       : title screen
  02_game       : fresh game scene (right after pressing ENTER)
  03_dragging   : mid-drag while drawing a path
  04_paths_done : complete path between goat farm and goat yurt
  05_settler    : settler en route on the new path
  06_score      : settler delivered, score advanced
  07_lost       : an unfed farm has overflowed, loss banner up
"""

from __future__ import annotations

import sys
from pathlib import Path

_PORT_DIR = Path(__file__).parent
if str(_PORT_DIR) not in sys.path:
    sys.path.insert(0, str(_PORT_DIR))

from nodes import iso  # noqa: E402

from simvx.core.input.enums import Key  # noqa: E402
from simvx.core.testing.input_sim import InputSimulator  # noqa: E402
from simvx.graphics import App, save_png  # noqa: E402

WIDTH = 1280
HEIGHT = 720


def _cell_to_screen(cell: tuple[int, int]) -> tuple[float, float]:
    return iso.world_to_screen(*cell)


def main() -> None:
    from main import TinyYurtsRoot  # noqa

    sim = InputSimulator()
    captures: dict[int, str] = {}

    # We schedule actions by frame index. Each tuple (frame, fn).
    # We give the app some warm-up to register the InputMap and render the menu.
    schedule: list[tuple[int, callable]] = []

    # Frame 30: capture menu
    captures[30] = "01_menu.png"

    # Frame 40: press ENTER to start game
    def press_enter() -> None:
        sim.press_key(Key.ENTER)

    schedule.append((40, press_enter))

    def release_enter() -> None:
        sim.release_key(Key.ENTER)

    schedule.append((42, release_enter))

    # Frame 70: capture fresh game (after scene change settles)
    captures[70] = "02_game.png"

    # Now: draw goat-farm (9, 2) -> goat-yurt (7, 4) along (8,2)(8,3)(7,3)(7,4)
    drag_cells = [(9, 2), (8, 2), (8, 3), (7, 3), (7, 4)]

    # Frame 80: start drag at (9, 2)
    start_cell = drag_cells[0]

    def drag_start() -> None:
        sx, sy = _cell_to_screen(start_cell)
        sim.move_mouse(sx, sy)
        sim.press_mouse(button=0, position=(sx, sy))

    schedule.append((80, drag_start))

    # Frames 84, 88, 92, 96: move through cells (one per step)
    for i, cell in enumerate(drag_cells[1:], start=1):
        f = 80 + i * 4

        def make_move(c=cell):
            def fn() -> None:
                sx, sy = _cell_to_screen(c)
                sim.move_mouse(sx, sy)

            return fn

        schedule.append((f, make_move()))

    # Frame 102: capture mid-drag (cursor on penultimate cell)
    captures[100] = "03_dragging.png"

    # Frame 104: release mouse
    def drag_end() -> None:
        sim.release_mouse(button=0)

    schedule.append((104, drag_end))

    # Frame 110: capture completed paths
    captures[110] = "04_paths_done.png"

    # Frame 200: settler should be moving by now
    captures[200] = "05_settler.png"

    # Frame 360: give farms time to keep ticking, settlers should have delivered
    captures[360] = "06_score.png"

    # Frame 900: let unfed fish farm overflow → loss screen
    captures[900] = "07_lost.png"

    # Run simulation long enough to see the loss
    total_frames = 920

    def on_frame(idx: int, _t: float) -> None:
        for f, fn in schedule:
            if f == idx:
                fn()

    capture_indices = sorted(captures.keys())

    app = App(width=WIDTH, height=HEIGHT, title="Tiny Yurts (harness)", visible=False)
    frames = app.run_headless(
        TinyYurtsRoot(),
        frames=total_frames,
        on_frame=on_frame,
        capture_frames=capture_indices,
    )

    out_dir = _PORT_DIR / "screenshots"
    out_dir.mkdir(exist_ok=True)
    for idx, img in zip(capture_indices, frames, strict=False):
        name = captures[idx]
        out_path = out_dir / name
        save_png(img, out_path)
        print(f"saved {out_path}")


if __name__ == "__main__":
    main()