A platform fighting game that is also an arena for AI agents. Any agent that can speak MCP (a Claude client, a Python script, your own bot in any language) can walk in, discover the controls, and fight: against the built-in CPU, against another agent, or against you.
Built on Collider, a code-first 2D game engine for Go whose games are agent-playable out of the box. That's why it was chosen: Collider treats "an AI can play this" as an engine feature, not an afterthought, and this game pushes that idea as far as it goes.
Two external agents fighting over MCP. The HUD says who's at the
controls: PLAYER-1, CPU-2, or AGENT-1.
The game binary is the server: nothing to install, no SDK required. Run it with two environment variables and its stdio speaks MCP (newline-delimited JSON-RPC 2.0):
$env:COLLIDER_AGENT = "mcp" # headless; "mcp-window" = real time, watchable
$env:FIGHTER_MATCH = "p1=agent:kael,p2=cpu2:torg,stage=skyreach,stocks=3"
go run . # or the built fighter.exeOr hand it straight to an MCP client:
claude mcp add fighter -e COLLIDER_AGENT=mcp -e "FIGHTER_MATCH=p1=agent:kael,p2=cpu2:torg" -- C:\path\to\fighter.exeEverything an agent needs is served on connect, no docs required:
- initialize returns the rules and a match briefing: stage geometry, blast zones, both fighters' stats and per-move frame data.
- act lists this game's controls in its own description
(
p1-attack,p1-heavy,p2-jump, ...) and holds them for N ticks. - Every observation carries the full battle state: positions, damage, stocks, state machines, hitstun, projectiles.
Headless matches step deterministically and simulate in seconds,
built for training and evaluation loops. mcp-window runs the same
match in the real-time window, where agent input merges with the
keyboard: that's how a person fights an agent in the same game.
Every matchup works:
| Matchup | How |
|---|---|
| Player vs CPU | the normal game (go run .) |
| Player vs Agent | arena -p1 human -p2 sage -window |
| Agent vs CPU | arena -p1 berserker -p2 cpu3 |
| Agent vs Agent | arena -p1 berserker -p2 sage |
Two Claude-powered example agents ship in
examples/agents as references for
building your own: BERSERKER, a relentless rushdown strategist, and
SAGE, which profiles the opponent's habits and counter-picks. Each
pairs a Claude strategist (a tactic decision every ~2s) with a
deterministic micro-policy (frame-level execution). The arena command
above runs any matchup, including a scripted bot that needs no API
key. The examples README documents the wire format with a complete
Python agent in ~20 lines.
A polished platform fighter in its own right: knockback rises with damage, KOs happen past the blast zone, last stock standing wins.
go run .- Four fighters with distinct silhouettes and frame data: Kael the Tide Blade (swordsman, wave projectile), Torg the Mountain (slow, armored, huge damage), Lyra the Starweaver (floaty zoner, warp recovery), Volt the Live Wire (fastest in the game).
- 18 moves each: jabs, tilts, chargeable smashes, five aerials with a meteor, dash attack, grab and throws, two specials.
- Movement: dashes, double jumps, fast-fall, drop-through platforms, ledge grabs, shields, rolls, spot and air dodges.
- Two stages: Skyreach Temple (day, wind, drifting clouds) and Neon Harbor (night, rain, neon, lightning), with parallax and a dynamic camera.
- Modes: local versus (2P or vs CPU levels 1-3), training, stocks or timed rules.
- Feel: hitstop, screen shake, KO slow-motion, hit sparks, baked weapon trails, squash-and-stretch everywhere.
| Action | P1 | P2 |
|---|---|---|
| Move | W A S D | Arrows |
| Jump | Space | Numpad 0 / Right Ctrl |
| Attack | J | Numpad 1 / , |
| Heavy (hold to charge) | K | Numpad 2 / . |
| Special | L | Numpad 3 / / |
| Grab | U | Numpad 4 / M |
| Shield / dodge | Left Shift | Right Shift |
Esc pauses. F11 toggles fullscreen. Every sprite, sound and song is generated procedurally by code in this repository, no hand-drawn assets anywhere.
Collider provides the window, scenes, objects, input, text, audio and the MCP agent server; this game provides a 60Hz world-space battle simulation on top (platform-fighter physics don't fit AABB-solid resolution) and renders it through pooled Collider scene objects projected by its own camera.
The agent story is pure engine API. Three optional calls make any Collider game, however complex, fully agent-playable:
g.Controls(battle.MCPControls()) // named inputs, self-described to agents
g.AgentState(func() any { ... }) // full game state in every observation
g.AgentDocs("rules + match briefing JSON") // served on MCP connectIf you're building your own Collider game, the same three lines put it in reach of every agent that can play this one.
main.go window, embedded assets, agent/demo modes
gamestate/ JSON shapes of the agent-facing state
internal/data single source of truth: stats, frame data, balance
internal/battle fighter state machines, physics, hits, camera, HUD, FX
internal/agentmode FIGHTER_MATCH parsing + the three engine agent hooks
internal/ai built-in CPU opponents
internal/menus title, selects, rules, settings, results
examples/agents Claude example agents, policy layer, MCP client, arena
tools/genassets generates every asset into assets/
go test . # headless battle + MCP end-to-end tests
go run ./tools/genassets # regenerate all art/audio (characters ~2 min)
$env:FIGHTER_DEMO='battle'; $env:COLLIDER_RECORD='docs/demo.gif'; go run . # record a CPU demoFonts are Bungee and Rajdhani (SIL Open Font License). During
development the engine is used from a local checkout via go.work
(see AGENTS.md).