Add 2 new arenas

Author: john-b-yang

.claude/skills/write-arena-page/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: write-arena-page
+description: >-
+  Write the codeclash.ai arena page for a CodeClash arena. Use when asked to
+  "write/add an arena page", "document an arena on the website", or "write up
+  <arena> for the site". Produces pages/arenas/<arena>.md matching site conventions.
+---
+
+# Write an Arena Page
+
+An arena page is a single markdown file, `pages/arenas/<arena>.md`, with a
+key-value front matter block followed by the write-up body. `server.py` serves it
+at `/arenas/<arena>/`, `templates/arena.html` renders it, and `templates/arenas.html`
+auto-lists it on the index (sorted by title) — **no registration anywhere else.**
+
+## Learn the arena first (don't write from the description alone)
+
+The prompt's blurb is a starting point, not the source of truth. Before writing:
+
+1. **Read the arena class** `repo/codeclash/arenas/<arena>/<arena>.py` — its `name`,
+   `submission` file, `description`, and `validate_code` define the exact bot contract.
+2. **Read the arena's own repo** (the Dockerfile `git clone`s `CodeClash-ai/<Arena>`).
+   Its `README.md` + engine are the ground truth for rules, physics constants, the
+   `obs`/state shape, actions, scoring, and win condition. Prefer engine code over the
+   README when they disagree, and note the real starting conditions (e.g. balls that
+   start at rest, side-swapping across seeded games).
+3. **Read the test config** `repo/configs/test/<arena>.yaml` for player count and the
+   `game_description` prompt shown to agents.
+4. **Read 2-3 existing pages** in `pages/arenas/` to match tone and depth. Short
+   train-split arenas (`bomberland.md`, `scml.md`) are the default shape; big
+   test-split / ladder arenas (`battlesnake.md`, `corewar.md`) add extra sections.
+
+## Front matter (one `key: value` per line, no `---` fences)
+
+```
+title: <Display name>
+logo: /static/images/arenas/<arena>.png
+preview: /static/images/arenas/<arena>.gif
+preview_width: 55            # optional, % width of the preview (default 50)
+description: <one line, imperative, no period — shown on the index card>
+date-added: <YYYY>-<MM>-<DD>T00:00:00.000000Z   # date the arena was added
+players: 2+                  # or an exact count, matching the arena/config
+language: Python             # comma-separated; must have a matching static/images/languages/<lang>.svg
+split: train                 # train = no leaderboard; test = renders the Leaderboard section
+ladder: true                 # optional; adds the 🪜 badge + expects a CC:Ladder section
+```
+
+Set `split: test` only for arenas that have leaderboard data in `data/leaderboards.json`
+(keyed by the page slug); otherwise `train`. Add `ladder: true` only if a CC:Ladder
+exists — then include a `## 🪜 CC:Ladder` section (see `battlesnake.md`).
+
+## Body
+
+Four bold-question sections in this order, each one tight paragraph:
+
+- **What is `<Arena>`?** — the game in one or two sentences + the win condition.
+- **How does it work?** — the submission file, the entry function + its signature, the
+  legal actions/return values, what `obs` (game state) contains, and how a round is scored.
+- **What's the goal?** — the objective and the core scoring mechanic; call out any
+  non-obvious rule (e.g. "doing nothing scores nothing").
+- **What makes it challenging?** — the real strategic tension, concretely.
+
+Then a `---`, an `### References` list (the arena's own repo + the CodeClash repo), and —
+**only if the arena ports an external game** — a `<pre>` BibTeX block crediting the
+original creators (see `bomberland.md`). Original CodeClash games need no third-party
+citation.
+
+## Accuracy rules
+
+- Quote real numbers (grid size, tick budget, key physics constants) from the engine, not
+  guesses. Preserve the arena's own terminology.
+- State exact action strings / return values and the entry-function signature verbatim.
+- Don't invent features, external inspirations, or citations the repo doesn't support.
+
+## Assets (separate deliverable)
+
+The page references `static/images/arenas/<arena>.png` (logo) and `.gif` (gameplay
+preview). These are generated from a replay, not hand-authored — if they don't exist yet,
+write the page with the conventional paths and flag that the two image assets still need to
+be produced. Never commit a fabricated/placeholder binary.
+
+## Verify
+
+Run `python server.py` in `website/` and open `/arenas/<arena>/` and `/arenas/`, or
+`python server.py build` to freeze. Confirm the page renders, the card appears on the
+index, and the language icon resolves.

pages/arenas/lightcycles.md

@@ -0,0 +1,30 @@
+title: LightCycles
+logo: /static/images/arenas/lightcycles.png
+preview: /static/images/arenas/lightcycles.gif
+preview_width: 80
+description: Tron cycles carve trails to box rivals in and outlast them
+date-added: 2026-07-08T00:00:00.000000Z
+players: 2+
+language: Python
+split: train
+
+**What is LightCycles?**
+LightCycles is Tron light-cycles. Each player drives a cycle around a bordered grid, leaving a solid trail behind it, while static rock obstacles dot the field. Every tick all cycles move one cell at the same time, and you crash if you steer into a wall, a rock, any trail (yours or an opponent's), or the cell another cycle enters that tick. The last cycle still riding wins.
+
+**How does it work?**
+Each player writes a Python file (`main.py`) that defines `get_move(obs) -> str`, called once per tick. It returns a direction—`N`, `S`, `E`, or `W`—to steer; reversing directly back into your own neck is ignored (you keep going straight), as is an invalid, crashing, or too-slow move. Your bot receives `obs`, the complete deterministic game state: the current tick and cap, the grid dimensions, your id, every cycle (`id`, `x`, `y`, `dir`, `alive`), and the full `grid` where each cell holds a player id, `-1` for empty, or `-2` for a rock. The board is 48×36 with a 2000-tick safety cap; rocks are scattered with 180° rotational symmetry so both sides start on equal footing. Each round plays several seeded games with jittered spawn positions and directions.
+
+**What's the goal?**
+Be the last cycle riding. If everyone still alive crashes on the same tick it's a draw, and if the tick cap is reached with more than one survivor, whoever holds the most territory—the most trail cells—wins. Since the whole grid is visible and every move is simultaneous, the game rewards looking ahead: keeping your own space open while shrinking your opponent's.
+
+**What makes it challenging?**
+Because moves resolve simultaneously, you can't just react to where opponents are—their head cell this tick becomes solid trail next tick, so you must reason about where everyone will be. The real skill is spatial: avoiding moves that trap you in a small pocket later, flood-filling the space each option leaves you, and using walls, rocks, and your own trail to wall off territory the opponent can't reach. Head-ons kill both cycles, so you can force trades when you have more room to retreat into than they do. The board is finite, and the endgame comes down to who runs out of space first.
+
+---
+
+### References
+
+* [LightCycles on GitHub (CodeClash-ai/LightCycles)](https://github.com/CodeClash-ai/LightCycles)
+* [CodeClash GitHub Repository](https://github.com/CodeClash-ai/CodeClash)
+* [Tron (1982 film)](https://en.wikipedia.org/wiki/Tron) — origin of the light-cycle concept
+* [Google AI Challenge](https://en.wikipedia.org/wiki/Google_AI_Challenge) — the 2010 University of Waterloo / Google-sponsored contest whose game was Tron light cycles

pages/arenas/paintvolley.md

@@ -0,0 +1,28 @@
+title: PaintVolley
+logo: /static/images/arenas/paintvolley.png
+preview: /static/images/arenas/paintvolley.gif
+preview_width: 80
+description: Helmet-wearing bots bounce balls to paint the most territory
+date-added: 2026-07-08T00:00:00.000000Z
+players: 2+
+language: Python
+split: train
+
+**What is PaintVolley?**
+PaintVolley is a territory-painting game where each player controls a helmet-wearing character that patrols the bottom of a rectangular field. Balls fly around above, bouncing off all four walls with no gravity, and every tick each ball paints the tile it passes over in its own color. Whoever owns the most tiles when the tick budget runs out wins.
+
+**How does it work?**
+Each player writes a Python file (`main.py`) that defines `get_action(obs) -> str`, called once per tick. It returns one of `LEFT`, `RIGHT`, `JUMP`, `JUMP_LEFT`, `JUMP_RIGHT`, or `NONE`; an invalid, crashing, or too-slow action becomes `NONE` for that tick. Your bot receives `obs`, the complete deterministic game state—current tick, field dimensions, every physics constant, all players (position and whether they're grounded), all balls (position, velocity, and owner), the painted tile grid, and the scores—so you can forward-simulate ball trajectories and plan where to stand. Each round plays several seeded games with jittered starting layouts, and the winner is decided by games won.
+
+**What's the goal?**
+Own more tiles than everyone else. Balls start neutral and motionless, resting above each character's head, and a neutral ball paints nothing—so doing nothing scores nothing. When a ball touches your helmet it recolors to your color and launches back up, painting for you until an opponent steals it. The spot where the ball strikes the helmet sets its exit angle (center sends it straight up, edges kick it out steeply), so you aim where your paint goes by choosing where to make contact.
+
+**What makes it challenging?**
+You never touch a tile directly—you paint only by shepherding balls, which demands predicting bounces several ticks ahead and being in the right place to intercept. Characters are solid: you can be blocked by an opponent, jump over them, or land on their head (which pins them from jumping), so positioning is contested. Winning means keeping your own balls in play, aiming them into unclaimed or enemy territory, and stealing the opponent's balls to cut off their paint stream while starting your own.
+
+---
+
+### References
+
+* [PaintVolley on GitHub (CodeClash-ai/PaintVolley)](https://github.com/CodeClash-ai/PaintVolley)
+* [CodeClash GitHub Repository](https://github.com/CodeClash-ai/CodeClash)