@pi-in-go/pigpen-angry-pigs 0.1.0

package/CREDITS.md

@@ -0,0 +1,18 @@
+# Credits
+
+`extensions/angrypigs` is the `angrypigs` extension of **PiG**,
+https://github.com/MichaelKinsy/PiG, written by **Michael Kinsy**
+(Copyright (c) 2026 Michael Kinsy, MIT; see [LICENSE](LICENSE)), moved into
+Pigpen as a Package at the owner's request.
+
+- Original: `piglets/standard/extensions/angrypigs` at commit
+  `d86eb93f217e64b655e9ee6f48c93a9afd107697` (game, art, render, particles, component, state and all tests).
+- The pig, the pixel rasterizer, the arcade scenery and the terminal plumbing come from the
+  shared Package [`pig-play`](../pig-play/CREDITS.md) (formerly `piglets/standard/internal/*` and
+  the sprite catalogue of `piglogin`).
+- Angry Pigs wears PiG Runner's look (night sky, turf, HUD lines, title cards) through the shared `arcade` library.
+
+What changed: the sprite type and palette come from `pig-play`'s `sprite` library, and the pixel,
+arcade and termgame imports point at `pig-play` instead of PiG Standard's `internal/`. Game rules,
+art, rendering, key bindings, messages, the saved high score path and every test are unchanged.
+[`port/PORT.md`](port/PORT.md) lists the differences and the tests.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Kinsy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# angry-pigs
+
+Angry Pigs, from PiG Standard's `angrypigs`: a pixel-art slingshot game drawn over the whole
+terminal. Your pig (the sprite chosen with `/sprite`) flies at bird-topped towers of wood, stone
+and ice that crack, shatter and collapse; a gauge, a trajectory preview and particles show the
+shot. Physics runs at a fixed 120 Hz step; a camera pans over the fixed-size world and a minimap
+shows the whole field when the terminal is narrower than the world.
+
+**It does not start by itself.** The extension registers one command and no event handlers (only with
+`PIG_GAMES_MCP=1` set does it add one `session_start` handler, for the opt-in agent server below), so
+bundling it into a Piglet (as `pig-with-batteries` does) does nothing until you type:
+
+```text
+/angry-pigs
+```
+
+Keys: Up / Down pull the band back for power, Left / Right aim, Space start and fire, P pause,
+R restart, Esc / Q leave; a mouse drag aims when the terminal reports the mouse. The high score
+is kept in `$PIG_HOME/state/pig-standard/angrypigs.json`. The game draws a modal overlay with its
+own ticker and never waits on the agent; Esc closes only the overlay.
+
+## Let an agent play (opt-in)
+
+Off by default: nothing listens until you ask.
+
+```text
+/angry-pigs mcp on       serve Angry Pigs to an agent on 127.0.0.1 for this session
+/angry-pigs mcp off      stop it
+/angry-pigs mcp status
+```
+
+or start pig with `PIG_GAMES_MCP=1`. The server is `games-angry-pigs`: five tools, found from a codemode script with
+`searchTools("game")` (`mcp__games_angry_pigs__...`), behind a random bearer token that only the registered config holds.
+The mechanism is the shared library [`gamemcp`](../pig-play/README.md#let-an-agent-play-gamemcp).
+
+| Tool | Result |
+|---|---|
+| `games_list()` | `[{name: "angry-pigs", description, instructions, actions}]`; `instructions` say what each action does to the shot |
+| `game_start({name: "angry-pigs"})` | opens the same overlay `/angry-pigs` opens, past the title screen: `{ok, game}` |
+| `game_state()` | `{shots_left, score, level, level_done, game_over, flying, targets: [{x, y, material}], pig: {power, angle}, aim_landing: {x, y, hit} or null, landing_vs_target, landing_vs_target_px, last_shot_result: {outcome, birds_knocked}}` |
+| `game_act({action, confidence?})` | `aim_up`, `aim_down` (the angle, one degree: the Left and Right keys), `power_up`, `power_down` (the pull, three percent: the Up and Down keys), `fire`, `none`, after a result `next_level` or `restart`, and `stop`; queued, applied on the next frame as the key press: `{ok, decisions}` |
+| `game_score({wait_closed_ms?})` | `{score, high_score, decisions, game_over, open, stopped}`, also after the game closed; the high score is saved in `<config home>/state/pig-standard/angrypigs.json` |
+
+`x` and `y` are world pixels: x grows right from the left edge, y grows up from the ground, and the slingshot rests at
+(44, 15). `targets` lists every bird (material `bird`) and the top block of each tower column (`wood`, `stone`, `ice`) at the
+centre of its 6-pixel cell. `aim_landing` is where the aimed shot ends, with what stops it (`ground`, a block material,
+`bird`, or `""` when it leaves the field): the preview's flight carried on to its end, with no randomness in it. It reaches
+farther than the screen does. The 24 preview dots show the first 1.2 s of the flight, so a person sees where the dots head
+and judges the rest, while `aim_landing` gives the agent the end point (on level 1 most shots that reach the bird reach it
+after the last dot). A shot it says reaches a bird can still miss, since the pig is a disc and the flight a point. `landing_vs_target` says it
+in words against the nearest bird: `on target` (the shot ends at a bird), `short by N px` or `long by N px`
+(`landing_vs_target_px` is the signed difference, negative when short; `no shot to aim` while a pig flies or after a
+result). `last_shot_result.outcome` is `none`, `landed`, `hit_structure` or `off_field`.
+
+**What the actions do** (also in `instructions`): `power_up` pulls the band further, so the shot flies faster and lands
+further away; it is the main way to reach a far bird (on level 1 the start aim, 45 degrees at power 70, lands about 37 px
+short, and a few `power_up` reach the bird). `power_down` brings the landing closer. `aim_up` raises the arc (over a tower
+in the way; above 45 degrees it also lands a little closer), `aim_down` flattens it; an angle step moves the landing far
+less than a power step. Fire when `landing_vs_target` is `on target`: short means `power_up` (at full power `aim_up`),
+long means `power_down`.
+
+The overlay shows "AI playing: last decision power_up p=0.92 · decisions 12" while an agent plays. `game_act` `stop` ends
+the play: the game freezes, the high score is saved, and the HUD shows "AI stopped · final score N · high score M ·
+decisions K · any key closes"; the next key closes the overlay and reports the score. (A Go extension cannot close its own
+overlay yet: the SDK has no done callback, so the closing key is the user's.) Esc closes the overlay at any time and ends
+the game for the agent too. The demo that has Jev play it is
+[`demo/jev-plays.js`](../../demo/README.md).
+
+Needs the sibling Package [`pig-play`](../pig-play/README.md) (`../pig-play`) when built from
+source, and a Go toolchain unless fused into a Piglet Binary.
+
+```sh
+pig package validate ./components/angry-pigs
+pig install ./components/angry-pigs/extensions/angrypigs --validate-only --json
+```
+
+Credits and licence: [CREDITS.md](CREDITS.md), [LICENSE](LICENSE) (MIT).

package/extensions/angrypigs/agentplay_test.go

@@ -0,0 +1,147 @@
+package angrypigs
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/MichaelKinsy/pigpen/components/pig-play/libraries/gamemcp"
+)
+
+// classifierLatency is 0.7 s of decision time, what a Jev decision takes in the demo, in
+// physics steps.
+const classifierLatency = 84
+
+// playWithLatency plays through the agent path (game_state, then game_act on the component's
+// queue) with one decision in flight that lands latency steps after its state was read, while
+// the game keeps running. It stops when the level is done, the game is over, or after
+// maxSeconds of game time.
+func playWithLatency(c *component, latency int, maxSeconds float64, decide func(map[string]any) string) (steps, decisions int) {
+	pending, due := "", -1
+	for ; float64(steps)*stepSeconds < maxSeconds; steps++ {
+		if due == steps {
+			_ = c.queueAction(pending)
+			decisions++
+			due = -1
+		}
+		c.mu.Lock()
+		c.applyQueuedLocked()
+		c.game.step()
+		done := c.game.levelDone || c.game.gameOver
+		c.mu.Unlock()
+		if done {
+			return steps, decisions
+		}
+		if due < 0 {
+			pending, due = decide(c.agentState()), steps+latency
+		}
+	}
+	return steps, decisions
+}
+
+// The rule-based player, deciding from the state's words with 0.7 s per decision, clears
+// level 1: it knocks out the bird before it runs out of pigs.
+func TestRulePlayerWithSlowDecisionsClearsLevelOne(t *testing.T) {
+	c := idleComponent(t)
+	c.attachAgent(&gamemcp.Agent{})
+	steps, decisions := playWithLatency(c, classifierLatency, 120, func(state map[string]any) string {
+		action, _ := fakeJev(state)
+		return action
+	})
+	g := c.game
+	if !g.levelDone || g.gameOver {
+		t.Fatalf("level 1 not cleared after %.1f s, %d decisions: score %d, pigs left %d, %s", float64(steps)*stepSeconds, decisions, g.score, g.pigsLeft, g.lastEvent)
+	}
+	t.Logf("level 1 cleared in %.1f s with %d decisions, %d pigs used, score %d", float64(steps)*stepSeconds, decisions, levelPigs[0]-g.pigsLeft, g.score)
+}
+
+// Firing whenever a shot can be aimed, at the start aim, never reaches the bird: the rule's
+// adjustments are what clear the level.
+func TestFiringAtTheStartAimDoesNotClearLevelOne(t *testing.T) {
+	c := idleComponent(t)
+	c.attachAgent(&gamemcp.Agent{})
+	playWithLatency(c, classifierLatency, 120, func(state map[string]any) string {
+		if state["aim_landing"] != nil {
+			return "fire"
+		}
+		return "none"
+	})
+	if c.game.levelDone {
+		t.Fatal("level 1 cleared without aiming")
+	}
+}
+
+// landing_vs_target says, in words, where the aimed shot ends against the nearest bird.
+func TestLandingVersusTargetInWords(t *testing.T) {
+	g := newGame(80, 0)
+	state := g.agentFacts()
+	landing := state["aim_landing"].(map[string]any)
+	bird := state["targets"].([]map[string]any)[0]
+	if bird["material"] != "bird" {
+		t.Fatalf("first target %v", bird)
+	}
+	short := bird["x"].(int) - landing["x"].(int)
+	if want := "short by " + itoa(short) + " px"; short <= 0 || state["landing_vs_target"] != want || state["landing_vs_target_px"] != -short {
+		t.Fatalf("start aim: landing %v, bird %v, landing_vs_target %q (%v), want %q", landing, bird, state["landing_vs_target"], state["landing_vs_target_px"], want)
+	}
+	// power_up moves the landing further, as the instructions say.
+	g.aim(0, powerStep)
+	further := g.agentFacts()["aim_landing"].(map[string]any)["x"].(int)
+	if further <= landing["x"].(int) {
+		t.Fatalf("power_up moved the landing from %v to %d", landing["x"], further)
+	}
+	for _, c := range []struct {
+		x    int
+		hit  string
+		want string
+		px   int
+	}{
+		{189, "bird", "on target", 0},
+		{150, "ground", "short by 39 px", -39},
+		{200, "ground", "long by 11 px", 11},
+		{180, "wood", "short by 9 px", -9},
+	} {
+		got, px := landingVersusTarget(c.x, c.hit, []map[string]any{{"x": 189}})
+		if got != c.want || px != c.px {
+			t.Errorf("landing %d hit %s: %q %d, want %q %d", c.x, c.hit, got, px, c.want, c.px)
+		}
+	}
+	if got, _ := landingVersusTarget(100, "ground", nil); got != "no bird left" {
+		t.Errorf("no bird: %q", got)
+	}
+}
+
+func itoa(n int) string { return strconv.Itoa(n) }
+
+// Stop freezes the game, shows the final score on the HUD, and the next key closes the overlay
+// with the score.
+func TestStopFreezesTheGameAndAnyKeyCloses(t *testing.T) {
+	c := idleComponent(t)
+	agent := &gamemcp.Agent{}
+	agent.Begin()
+	c.attachAgent(agent)
+	c.game.score = 550
+	saved, redraws := -1, 0
+	c.SetInvalidate(func() {
+		redraws++
+		if !agent.Stopped() {
+			t.Error("the redraw came before the HUD knew the final score")
+		}
+	})
+	p := &player{c: c, done: make(chan struct{}), save: func(high int) error { saved = high; return nil }}
+	final := p.Stop()
+	if redraws != 1 {
+		t.Fatalf("stop asked for %d redraws, want one for the final-score HUD", redraws)
+	}
+	if final.Score != 550 || final.HighScore != 550 || saved != 550 {
+		t.Fatalf("final %+v, saved %d", final, saved)
+	}
+	hud := strings.Join(c.Render(100), "\n")
+	if !strings.Contains(hud, "AI stopped") || !strings.Contains(hud, "final score 550") {
+		t.Fatalf("HUD after stop:\n%s", hud)
+	}
+	result, err := c.HandleInput("x")
+	if err != nil || !result.Done || result.Value.(gameState).Score != 550 {
+		t.Fatalf("key after stop: %+v %v", result, err)
+	}
+}

package/extensions/angrypigs/art.go

@@ -0,0 +1,164 @@
+package angrypigs
+
+import (
+	"image/color"
+
+	"github.com/MichaelKinsy/pigpen/components/pig-play/libraries/pixel"
+)
+
+func rgb(r, g, b uint8) color.RGBA { return color.RGBA{R: r, G: g, B: b, A: 0xFF} }
+
+// Scene colors.
+var (
+	bandColor    = rgb(0x3B, 0x22, 0x14)
+	dustColor    = rgb(0xE9, 0xDF, 0xC9)
+	puffColor    = rgb(0xFF, 0xFF, 0xFF)
+	trailColor   = rgb(0xFF, 0xFF, 0xFF)
+	previewDot   = rgb(0xFF, 0xFF, 0xFF)
+	hudInk       = rgb(0xFF, 0xFF, 0xFF)
+	hudShadow    = rgb(0x1B, 0x3A, 0x55)
+	hudGold      = rgb(0xFF, 0xD8, 0x4D)
+	featherColor = rgb(0xF4, 0xC4, 0x30)
+	meterFrame   = rgb(0x1B, 0x14, 0x10)
+	meterEmpty   = rgb(0x3A, 0x30, 0x2A)
+	meterLow     = rgb(0x5E, 0xD0, 0x6B)
+	meterMid     = rgb(0xFF, 0xD8, 0x4D)
+	meterHigh    = rgb(0xF0, 0x4E, 0x3A)
+)
+
+// Block materials: a 6x6 texture per material and its palette. 'h' is the lit
+// top edge, 'd' the shaded border that separates neighboring blocks.
+var (
+	woodTexture = []string{
+		"hhhhhd",
+		"wwwwwd",
+		"gggwwd",
+		"wwwwwd",
+		"wwgggd",
+		"dddddd",
+	}
+	stoneTexture = []string{
+		"hhhhhd",
+		"ssmssd",
+		"ssmssd",
+		"mmmmmd",
+		"sssmsd",
+		"dddddd",
+	}
+	iceTexture = []string{
+		"hhhhhd",
+		"hiiicd",
+		"ihiicd",
+		"iihicd",
+		"ccccid",
+		"dddddd",
+	}
+	woodPalette = pixel.NewPalette(map[byte]color.RGBA{
+		'h': rgb(0xE8, 0xAE, 0x68), 'w': rgb(0xC9, 0x8A, 0x4B), 'g': rgb(0xA1, 0x68, 0x35), 'd': rgb(0x6B, 0x42, 0x22),
+	})
+	stonePalette = pixel.NewPalette(map[byte]color.RGBA{
+		'h': rgb(0xC2, 0xC8, 0xD0), 's': rgb(0x9A, 0xA0, 0xA9), 'm': rgb(0x74, 0x7A, 0x83), 'd': rgb(0x52, 0x57, 0x5E),
+	})
+	icePalette = pixel.NewPalette(map[byte]color.RGBA{
+		'h': rgb(0xFA, 0xFE, 0xFF), 'i': rgb(0xBF, 0xEC, 0xFB), 'c': rgb(0x96, 0xD7, 0xF0), 'd': rgb(0x5E, 0xB0, 0xD6),
+	})
+)
+
+// Crack overlays for blocks that took one and two hits of damage.
+var cracks = [...][]string{
+	nil,
+	{
+		"......",
+		"...x..",
+		"..x...",
+		"..xx..",
+		"......",
+		"......",
+	},
+	{
+		"....x.",
+		".x.x..",
+		"..x...",
+		".xx.x.",
+		"x...x.",
+		"......",
+	},
+}
+
+func materialColor(kind cellKind) color.RGBA {
+	switch kind {
+	case cellWood:
+		return woodPalette['w']
+	case cellStone:
+		return stonePalette['s']
+	case cellIce:
+		return icePalette['i']
+	}
+	return featherColor
+}
+
+// birdFrames are a 6x6 bird facing the slingshot, eyes open and blinking.
+// 'Y' body, 'y' belly, 'O' beak, 'W' eye white, 'K' pupil and brow, 'k'
+// crest and tail.
+var birdFrames = [2][]string{
+	{
+		"..kk..",
+		".KKYYk",
+		"YWKYYY",
+		"OOYYyY",
+		".YyyYY",
+		"..YYY.",
+	},
+	{
+		"..kk..",
+		".KKYYk",
+		"YKKYYY",
+		"OOYYyY",
+		".YyyYY",
+		"..YYY.",
+	},
+}
+
+var birdPalette = pixel.NewPalette(map[byte]color.RGBA{
+	'Y': rgb(0xF4, 0xC4, 0x30), 'y': rgb(0xFF, 0xE9, 0x9A), 'O': rgb(0xF0, 0x7A, 0x1E),
+	'W': rgb(0xFF, 0xFF, 0xFF), 'K': rgb(0x1F, 0x17, 0x14), 'k': rgb(0xC9, 0x8F, 0x12),
+})
+
+// pigBall is the 8x8 launched pig, drawn with the login sprite's palette so
+// it matches the selected pig.
+var pigBall = []string{
+	".OO..OO.",
+	"OeeOOeeO",
+	"OPPPPPPO",
+	"OWKPPKWO",
+	"ObPssPbO",
+	"OPsKKsPO",
+	".OPPPPO.",
+	"..OOOO..",
+}
+
+// slingshot is the 9x17 wooden fork. 'T' is lit wood, 't' shaded wood, 'b'
+// the rubber band's anchor.
+var slingshot = []string{
+	"bTT...TTb",
+	".Tt...Tt.",
+	".TT...TT.",
+	".tT...Tt.",
+	".TT...TT.",
+	"..TT.TT..",
+	"..tTTTt..",
+	"...TTT...",
+	"...tTt...",
+	"...TTT...",
+	"...TTt...",
+	"...TTT...",
+	"...tTT...",
+	"...TTT...",
+	"...TTt...",
+	"..tTTTt..",
+	".tttttt..",
+}
+
+var slingPalette = pixel.NewPalette(map[byte]color.RGBA{
+	'T': rgb(0xB0, 0x74, 0x3C), 't': rgb(0x80, 0x50, 0x28), 'b': bandColor,
+})

package/extensions/angrypigs/component.go

@@ -0,0 +1,254 @@
+package angrypigs
+
+import (
+	"sync"
+	"time"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+	"github.com/MichaelKinsy/pigpen/components/pig-play/libraries/gamemcp"
+	"github.com/MichaelKinsy/pigpen/components/pig-play/libraries/pixel"
+	"github.com/MichaelKinsy/pigpen/components/pig-play/libraries/sprite"
+	"github.com/MichaelKinsy/pigpen/components/pig-play/libraries/termgame"
+)
+
+const (
+	// frameInterval matches the SDK's render coalescing interval.
+	frameInterval = 16 * time.Millisecond
+	// idleInterval redraws the drifting clouds when nothing else moves.
+	idleInterval = 250 * time.Millisecond
+	// maxCatchUp bounds the simulated time after a stall.
+	maxCatchUp = 100 * time.Millisecond
+	// stepDuration is stepSeconds as a duration.
+	stepDuration = time.Second / 120
+	// powerStep is the power change per Up or Down press, in percent.
+	powerStep = 3
+)
+
+type gameState struct {
+	Score     int  `json:"score"`
+	HighScore int  `json:"highScore"`
+	Level     int  `json:"level"`
+	GameOver  bool `json:"gameOver"`
+}
+
+// component is the full-terminal remote component. Its loop advances the
+// physics at a fixed step off the TUI loop, ticking every frame while the
+// scene moves and a few times a second while it idles. The SDK coalesces the
+// resulting invalidations to its frame interval.
+type component struct {
+	mu         sync.Mutex
+	game       *game
+	scene      *scene
+	height     func() int
+	lastHeight int
+	lastFrame  time.Time
+	wasActive  bool
+	invalidate func()
+	stop       chan struct{}
+	stopped    chan struct{}
+	stopOnce   sync.Once
+	wake       chan struct{}
+	dragging   bool
+	// waiting holds the title screen until the player presses space.
+	waiting bool
+	// agent and queue serve an AI player (see mcp.go): the queue holds the key presses it
+	// asked for, which the next frame applies.
+	agent *gamemcp.Agent
+	queue []string
+	// stopped freezes the game once the agent stopped; saveErr is a failure to save the high
+	// score then, shown in the HUD.
+	agentStopped bool
+	saveErr      error
+}
+
+func newComponent(highScore int, variant sprite.Variant, height func() int) *component {
+	c := &component{
+		game:    newGame(80, highScore),
+		scene:   newScene(pixel.NewPalette(sprite.MascotPalette(variant))),
+		waiting: true,
+		height:  height,
+		stop:    make(chan struct{}),
+		stopped: make(chan struct{}),
+		wake:    make(chan struct{}, 1),
+	}
+	go c.run()
+	return c
+}
+
+func (c *component) run() {
+	defer close(c.stopped)
+	ticker := time.NewTicker(frameInterval)
+	defer ticker.Stop()
+	interval := frameInterval
+	last := time.Now()
+	var carry time.Duration
+	for {
+		select {
+		case <-ticker.C:
+		case <-c.wake:
+		case <-c.stop:
+			return
+		}
+		now := time.Now()
+		carry += min(now.Sub(last), maxCatchUp)
+		last = now
+		height := c.height()
+
+		c.mu.Lock()
+		queued := c.applyQueuedLocked()
+		stepped := false
+		if c.waiting || c.agentStopped {
+			carry = 0
+		}
+		for ; carry >= stepDuration; carry -= stepDuration {
+			c.game.step()
+			stepped = true
+		}
+		active := c.game.animating()
+		redraw := queued || stepped && (active || c.wasActive || now.Sub(c.lastFrame) >= idleInterval) || height != c.lastHeight
+		c.wasActive = active
+		if redraw {
+			c.lastFrame = now
+		}
+		c.lastHeight = height
+		invalidate := c.invalidate
+		c.mu.Unlock()
+
+		if redraw && invalidate != nil {
+			invalidate()
+		}
+		want := idleInterval
+		if active {
+			want = frameInterval
+		}
+		if want != interval {
+			interval = want
+			ticker.Reset(interval)
+		}
+	}
+}
+
+// Render draws the game to fill the overlay.
+func (c *component) Render(width int) []string {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	w, h := termgame.Viewport(width, c.height())
+	c.game.resize(w)
+	c.scene.waiting = c.waiting
+	c.scene.agentLine = ""
+	if c.agent != nil {
+		c.scene.agentLine = c.agent.Line()
+		if c.saveErr != nil {
+			c.scene.agentLine += " · high score not saved: " + c.saveErr.Error()
+		}
+	}
+	return c.scene.render(c.game, w, h, make([]string, 0, h))
+}
+
+func (c *component) HandleInput(data string) (sdk.RemoteComponentResult, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.inputLocked(data), nil
+}
+
+// inputLocked applies one input. The keyboard and an AI player's actions both come here.
+func (c *component) inputLocked(data string) sdk.RemoteComponentResult {
+	if c.agentStopped {
+		// The agent stopped: the final score is on the HUD, and any key closes.
+		return sdk.RemoteComponentResult{Done: true, Value: c.stateLocked()}
+	}
+	if c.waiting {
+		key, text := termgame.ParseKey(data)
+		switch {
+		case key == termgame.KeyEscape || key == termgame.KeyText && (text == 'q' || text == 'Q'):
+			return sdk.RemoteComponentResult{Done: true, Value: c.stateLocked()}
+		case key == termgame.KeyEnter || key == termgame.KeyText && text == ' ':
+			c.waiting = false
+			c.wakeLoop()
+		}
+		return sdk.RemoteComponentResult{}
+	}
+	if mouse, ok := termgame.ParseMouse(data); ok {
+		c.handleMouse(mouse)
+		return sdk.RemoteComponentResult{}
+	}
+	key, text := termgame.ParseKey(data)
+	switch {
+	case key == termgame.KeyEscape || key == termgame.KeyText && (text == 'q' || text == 'Q'):
+		return sdk.RemoteComponentResult{Done: true, Value: c.stateLocked()}
+	case key == termgame.KeyUp:
+		c.game.aim(0, powerStep)
+	case key == termgame.KeyDown:
+		c.game.aim(0, -powerStep)
+	case key == termgame.KeyLeft:
+		c.game.aim(1, 0)
+	case key == termgame.KeyRight:
+		c.game.aim(-1, 0)
+	case key == termgame.KeyEnter || key == termgame.KeyText && text == ' ':
+		c.game.launch()
+	case key == termgame.KeyText && (text == 'n' || text == 'N'):
+		c.game.nextLevel()
+	case key == termgame.KeyText && (text == 'r' || text == 'R'):
+		c.game.restart()
+	default:
+		return sdk.RemoteComponentResult{}
+	}
+	// Input can start motion while the loop idles; wake it for smooth frames.
+	c.wakeLoop()
+	return sdk.RemoteComponentResult{}
+}
+
+// handleMouse aims by dragging, as in the real game: press on the view,
+// drag to pull the band back, and release to launch. Terminals report mouse
+// input only when the host enables mouse tracking.
+func (c *component) handleMouse(m termgame.Mouse) {
+	if m.Button != 0 {
+		return
+	}
+	cx, cy := termgame.ViewCell(m)
+	x, y := c.scene.world(cx, cy*2+1)
+	switch {
+	case m.Release:
+		if c.dragging {
+			c.dragging = false
+			c.game.launch()
+			c.wakeLoop()
+		}
+	case m.Motion && !c.dragging:
+	default:
+		c.dragging = c.game.drag(x, y)
+	}
+}
+
+func (c *component) wakeLoop() {
+	select {
+	case c.wake <- struct{}{}:
+	default:
+	}
+}
+
+func (c *component) SetInvalidate(invalidate func()) {
+	c.mu.Lock()
+	c.invalidate = invalidate
+	c.mu.Unlock()
+}
+
+func (c *component) Dispose() {
+	c.stopOnce.Do(func() { close(c.stop) })
+	<-c.stopped
+}
+
+func (c *component) State() gameState {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.stateLocked()
+}
+
+func (c *component) stateLocked() gameState {
+	return gameState{
+		Score:     c.game.score,
+		HighScore: max(c.game.highScore, c.game.score),
+		Level:     c.game.level + 1,
+		GameOver:  c.game.gameOver,
+	}
+}