Add RoboCode CC:Ladder (80 imported classic-Robocode bots + build tooling)

- 80 open-source classic Robocode bots imported to CodeClash-ai/RoboCode human/robocode/*
  branches (source of truth, not committed here): shipped sample bots + mgalushka Super*
  variants; the full RoboWiki/PEZ collection (micro/mini/nano/femto + Marshmallow, GF1, Swiffer,
  ...); flat multi-file bots (Mb2, BerendBotje, MaximBot, TheCarver, BobTheBuilder, StarterBot);
  single-file DrussGT/HawkOnFire (strong top rungs); and bots from ~10 other GitHub repos
  (reimu, cham, pikachu, it-economics x8, ...). All copy-in (0 reimplementations) — verbatim,
  only repackaged to  + main class renamed to MyTank (helpers flattened).
- Each of the 80 verified to COMPILE and play a real battle in the arena image (stage 2, 80/80).
- Provenance: every port file carries a source-URL/author/license header; scripts/ladder/SOURCES.md
  is the committed manifest (slug -> GitHub URL). See stamp_sources.py.
- Fix arena description: it mislabeled itself 'Tank Royale' but the engine is classic Robocode.
- make_robocode.yaml: round-robin (100 rounds, ~1h local at -w6) for Elo; README note.
- scripts/ladder/: build tooling (copy-in porting guide, structural validator, compile+battle
  smoke, push script, provenance stamper, reference bot); ports/ regenerated, not committed.

Author: john-b-yang

codeclash/arenas/robocode/robocode.py

@@ -18,8 +18,12 @@
 
 class RoboCodeArena(CodeArena):
     name: str = "RoboCode"
-    description: str = f"""Robocode (Tank Royale) is a programming game where your code is the tank: each turn your bot sends intents—speed plus body/gun/radar turn rates and firepower—based on the game state it perceives via radar.
-Your program decides how to move, aim, and fire in a deterministic, turn-based arena to outlast other bots.
+    description: str = f"""Robocode is a programming game where your code IS the tank. This is classic
+Robocode (the `robocode.*` API compiled against robocode.jar) — NOT Robocode Tank Royale.
+Your bot is a Java class that `extends robocode.Robot` (or `robocode.AdvancedRobot` for non-blocking
+control): its `run()` method drives the tank in a loop (e.g. `ahead(100)`, `turnGunRight(90)`,
+`fire(3)`), and it reacts to events like `onScannedRobot(ScannedRobotEvent)`, `onHitByBullet(...)`,
+and `onHitWall(...)`. Move, aim the gun, sweep the radar, and fire to outlast other bots.
 Your bot logic must be written in Java and located in the `robots/custom/` directory.
 Keep the main bot class named `{str(RC_FILE)}`, but you can include additional Java files if you'd like."""
     default_args: dict = {

configs/ablations/ladder/README.md

@@ -12,6 +12,19 @@ You can follow these steps to create your own "CC:<arena>" ladder.
 The tricky part is typically finding a large collection of human solutions for a particular arena.
 We've typically found that googling for online leaderboards or awesome-<arena> repositories (e.g. [BattleSnake](https://github.com/BattlesnakeOfficial/awesome-battlesnake)) is a good strategy.
 
+### RoboCode (newly added)
+
+The [CC:RoboCode](https://github.com/CodeClash-ai/RoboCode) repo hosts 80 human bots on `human/robocode/*`
+branches (bot code lives only on the branches, not in this repo). This arena is **classic Robocode**
+(`robocode.*` API compiled against `robocode.jar`), so importing open-source bots is mostly a
+mechanical copy-in + rename rather than a strategy rewrite: each bot's Java class(es) are placed in
+`robots/custom/`, the main class renamed to `MyTank`, `package custom;`. The set spans the shipped
+sample bots (SittingDuck/Walls/Corners/…) through famous RoboWiki/PEZ micro-mini bots (Aristocles,
+Pugilist, HawkOnFire) up to a single-file **DrussGT** (a world-class bot) as the top rung; a few use
+Robocode's sanctioned `getDataFile` persistence (degrades gracefully without cross-battle saves).
+Diamond/BeepBoop remain as future top rungs (nested-package multi-file → need flattening). Each import
+was verified to **compile and play a real battle**. Build tooling + per-bot source provenance (`SOURCES.md`) live in `scripts/ladder/`.
+
 ## Config layout
 
 Each arena has a few kinds of config in this folder:

configs/ablations/ladder/make_robocode.yaml

@@ -0,0 +1,180 @@
+# Round-robin over the human classic-Robocode bots (imported from open-source repos; see
+# scripts/ladder/SOURCES.md for each bot's origin URL/author/license), used to RANK them via
+# Elo/Bradley-Terry -> see robocode.yaml. rounds:0 = dummy players play baseline battles (no code
+# edits). N bots -> N*(N-1)/2 pairs; each pair plays sims_per_round rounds (batched 10 at a time,
+# sim_concurrency parallel). Bots live on CodeClash-ai/RoboCode human/* branches; Docker required.
+# COST (measured ~3.4s for a 50-round pair headless): at sims_per_round=100, 80 bots -> 3160 pairs
+# ~= 6 core-hours -> ~1 h on a laptop (--workers 6), ~12 min on a 32-core box (-w 30). Runs locally.
+# Run: uv run codeclash ladder make configs/ablations/ladder/make_robocode.yaml --workers 6
+tournament:
+  rounds: 0
+game:
+  name: RoboCode
+  sims_per_round: 100
+  sim_concurrency: 5
+  args:
+    nodisplay: true
+    nosound: true
+players:
+- agent: dummy
+  branch_init: human/robocode/aristocles
+- agent: dummy
+  branch_init: human/robocode/berendbotje
+- agent: dummy
+  branch_init: human/robocode/blackwidow
+- agent: dummy
+  branch_init: human/robocode/blackwidow_mini
+- agent: dummy
+  branch_init: human/robocode/bobthebuilder
+- agent: dummy
+  branch_init: human/robocode/cham
+- agent: dummy
+  branch_init: human/robocode/chironex_micro
+- agent: dummy
+  branch_init: human/robocode/chironex_mini
+- agent: dummy
+  branch_init: human/robocode/corners
+- agent: dummy
+  branch_init: human/robocode/crawler
+- agent: dummy
+  branch_init: human/robocode/crazy
+- agent: dummy
+  branch_init: human/robocode/dacruzer
+- agent: dummy
+  branch_init: human/robocode/droidpoet
+- agent: dummy
+  branch_init: human/robocode/drussgt
+- agent: dummy
+  branch_init: human/robocode/fire
+- agent: dummy
+  branch_init: human/robocode/frankie
+- agent: dummy
+  branch_init: human/robocode/genetic
+- agent: dummy
+  branch_init: human/robocode/gf1
+- agent: dummy
+  branch_init: human/robocode/gntest
+- agent: dummy
+  branch_init: human/robocode/gouldingi
+- agent: dummy
+  branch_init: human/robocode/gruffalo
+- agent: dummy
+  branch_init: human/robocode/haikupoet
+- agent: dummy
+  branch_init: human/robocode/haikuwalls
+- agent: dummy
+  branch_init: human/robocode/hawkonfire
+- agent: dummy
+  branch_init: human/robocode/hugbot
+- agent: dummy
+  branch_init: human/robocode/hypoleach
+- agent: dummy
+  branch_init: human/robocode/ianstank
+- agent: dummy
+  branch_init: human/robocode/icarus
+- agent: dummy
+  branch_init: human/robocode/ite_bomax
+- agent: dummy
+  branch_init: human/robocode/ite_claptrap
+- agent: dummy
+  branch_init: human/robocode/ite_cliffbot2
+- agent: dummy
+  branch_init: human/robocode/ite_ctbot
+- agent: dummy
+  branch_init: human/robocode/ite_florian2
+- agent: dummy
+  branch_init: human/robocode/ite_m9
+- agent: dummy
+  branch_init: human/robocode/ite_simple
+- agent: dummy
+  branch_init: human/robocode/ite_terminator
+- agent: dummy
+  branch_init: human/robocode/leach
+- agent: dummy
+  branch_init: human/robocode/leachpmc
+- agent: dummy
+  branch_init: human/robocode/littlebrother
+- agent: dummy
+  branch_init: human/robocode/littleevilbrother
+- agent: dummy
+  branch_init: human/robocode/mako
+- agent: dummy
+  branch_init: human/robocode/markiv
+- agent: dummy
+  branch_init: human/robocode/markrobo
+- agent: dummy
+  branch_init: human/robocode/marshmallow
+- agent: dummy
+  branch_init: human/robocode/maximbot
+- agent: dummy
+  branch_init: human/robocode/mb2
+- agent: dummy
+  branch_init: human/robocode/myfirstrobot
+- agent: dummy
+  branch_init: human/robocode/paolo
+- agent: dummy
+  branch_init: human/robocode/pikachu
+- agent: dummy
+  branch_init: human/robocode/poet
+- agent: dummy
+  branch_init: human/robocode/pugilist
+- agent: dummy
+  branch_init: human/robocode/ramfire
+- agent: dummy
+  branch_init: human/robocode/regullarmonk
+- agent: dummy
+  branch_init: human/robocode/reimu
+- agent: dummy
+  branch_init: human/robocode/sittingduck
+- agent: dummy
+  branch_init: human/robocode/smallpoet
+- agent: dummy
+  branch_init: human/robocode/spinbot
+- agent: dummy
+  branch_init: human/robocode/starterbot
+- agent: dummy
+  branch_init: human/robocode/supercorners
+- agent: dummy
+  branch_init: human/robocode/supercrazy
+- agent: dummy
+  branch_init: human/robocode/supermercutio
+- agent: dummy
+  branch_init: human/robocode/superramfire
+- agent: dummy
+  branch_init: human/robocode/superspinbot
+- agent: dummy
+  branch_init: human/robocode/supertracker
+- agent: dummy
+  branch_init: human/robocode/superwalls
+- agent: dummy
+  branch_init: human/robocode/swiffer
+- agent: dummy
+  branch_init: human/robocode/tannerbot1
+- agent: dummy
+  branch_init: human/robocode/tarektank
+- agent: dummy
+  branch_init: human/robocode/thecarver
+- agent: dummy
+  branch_init: human/robocode/tityus
+- agent: dummy
+  branch_init: human/robocode/tracker
+- agent: dummy
+  branch_init: human/robocode/trackfire
+- agent: dummy
+  branch_init: human/robocode/velocirobot
+- agent: dummy
+  branch_init: human/robocode/vertileach
+- agent: dummy
+  branch_init: human/robocode/vertimicro
+- agent: dummy
+  branch_init: human/robocode/walls
+- agent: dummy
+  branch_init: human/robocode/wallspoet
+- agent: dummy
+  branch_init: human/robocode/wallspoetas
+- agent: dummy
+  branch_init: human/robocode/wallspoethaiku
+- agent: dummy
+  branch_init: human/robocode/wavesurfing
+prompts:
+  game_description: RoboCode ladder

scripts/ladder/.gitignore

@@ -0,0 +1,4 @@
+# Regenerated build artifacts — bot ports live on the CodeClash-ai/<arena> branches
+# (source of truth), not in this repo. Populate ports/ locally when (re)building a ladder.
+ports/
+out/

scripts/ladder/PORTING_GUIDE.md

@@ -0,0 +1,45 @@
+# Importing a classic Robocode bot into the CodeClash arena
+
+This arena is **classic Robocode** (Java, `robocode.jar`), NOT Tank Royale. Importing an
+open-source classic bot is mostly a mechanical **copy-in + rename**, not a strategy rewrite.
+
+## The submission contract
+The submission is a directory `robots/custom/` containing Java source. The arena harness then:
+1. copies `robots/custom/*` into `robots/<player>/`,
+2. runs `sed 's/custom/<player>/g'` over every `.java` (this renames the `package custom` →
+   `package <player>` so bots are namespaced),
+3. compiles `javac -cp "libs/robocode.jar" robots/<player>/*.java`  ← **flat glob, one directory**,
+4. runs battles selecting `<player>.MyTank*`.
+
+`validate_code` requires `robots/custom/MyTank.java` to exist, compile, and produce `MyTank.class`.
+
+## Hard rules for a port (`ports/<slug>/`)
+Produce a directory `scripts/ladder/ports/<slug>/` containing:
+- **`MyTank.java`** — the bot's main class, **renamed to `public class MyTank`** (rename the source's
+  main class everywhere: declaration, constructors, and any self-references). It must
+  `extends robocode.Robot` (or `AdvancedRobot` / `TeamRobot` / `RateControlRobot` / `JuniorRobot`).
+- **`package custom;`** as the package line in `MyTank.java` and in *every* helper file. Replace any
+  original `package a.b.c;`.
+- **Helper classes** (if the bot is multi-file) as additional flat `.java` files in the same dir,
+  also `package custom;`. **No nested subdirectories** — the compile is a flat `*.java` glob, so a
+  bot that uses nested packages (e.g. `voidious/gun/…`) must be flattened or it won't compile.
+  Inner classes inside one file are fine (preferred).
+- **The literal substring `custom` must NOT appear anywhere except the `package custom;` lines.**
+  The harness's `sed s/custom/<player>/g` is a blind global replace, so any identifier, comment, or
+  string containing "custom" would be corrupted. Rename such tokens.
+
+## What's allowed / what breaks
+- Only the classic `robocode.*` API. No Tank Royale (`dev.robocode.tankroyale.*`).
+- Robocode runs under a security manager: **raw `java.io`, threads, reflection, and network are
+  blocked.** Persistent gun/enemy stats via the sanctioned `getDataFile()` +
+  `RobocodeFileOutputStream` are allowed but **may not persist** across our battles — such a bot
+  still compiles and plays, it just degrades to no saved data (fine; note it). If the source uses
+  raw `java.io`/threads/reflection, it will fail — flag and skip, or strip that path if it's optional.
+- Keep behavior faithful: do not "improve" the bot; only rename/repackage/flatten.
+
+## Deliverable + report
+Write the port dir `scripts/ladder/ports/<slug>/` (at minimum `MyTank.java`). It must be valid Java
+that would compile against `robocode.jar`. In your report note per bot: source repo/author, base
+class, #files, and any caveat (data-file use, "custom"-token rename you had to do, multi-file, or
+anything you had to strip). A reference `MyTank.java` lives at
+`scripts/ladder/examples/robots/custom/MyTank.java`.

scripts/ladder/README.md

@@ -0,0 +1,33 @@
+# Ladder build tooling (RoboCode)
+
+Operational one-off scripts for constructing a CC:Ladder for **classic Robocode**. Unlike the
+SCML/Gomoku ladders (which re-express bots into a function contract), Robocode importing is mostly
+a mechanical **copy-in + rename**: classic bots are Java classes that drop into `robots/custom/`.
+
+This is scaffolding, not product code — nothing under `codeclash/` imports it. The durable outputs
+are the `human/*` branches on `CodeClash-ai/RoboCode` (the bots) and the
+`configs/ablations/ladder/*.yaml` configs. Ports are **not** committed here (see `.gitignore`).
+
+## Files
+- `PORTING_GUIDE.md` — the classic-Robocode submission contract + copy-in/rename rules (main class
+  → `MyTank`, `package custom;`, flat files, no stray "custom" token). Hand to an import agent with
+  `examples/robots/custom/MyTank.java` as the reference.
+- `examples/robots/custom/MyTank.java` — reference bot (AdvancedRobot) + porting example.
+- `validate_ports.py` — stage 1 (structural, local): each `ports/<slug>/` has `MyTank.java` with
+  `class MyTank extends <RobocodeBase>`, `package custom;`, flat, no sed-hazard token. Writes `_stage1.json`.
+- `run_smoke_all.sh` — **stage 2 (the real gate):** in the arena Docker image, compile each port
+  (`javac -cp libs/robocode.jar`) and run a real 3-round battle vs `sample.Walls`; confirm it
+  compiles AND plays. Writes `_stage2.json` + per-bot compile/battle logs in `out/`.
+- `push_branches.sh` — push each stage-2-healthy `ports/<slug>/` to `CodeClash-ai/RoboCode` as
+  `human/robocode/<slug>` with the files under `robots/custom/`.
+- `RUN.md` — round-robin (`ladder make`) + Elo ranking instructions.
+
+## Typical flow
+1. Populate `ports/<slug>/MyTank.java` (fan out import agents with `PORTING_GUIDE.md`).
+2. `python3 scripts/ladder/validate_ports.py`   → stage 1 (structural)
+3. `bash scripts/ladder/run_smoke_all.sh`        → stage 2 (compile + battle each; needs Docker)
+4. `bash scripts/ladder/push_branches.sh`        → push healthy ports to branches
+5. Rank + assemble configs — see `RUN.md`.
+
+Note: `ports/` and `out/` are gitignored and shared on disk across branches — clean stale files
+(`rm -rf scripts/ladder/ports/* scripts/ladder/out`) when switching between arena ladder branches.

scripts/ladder/RUN.md

@@ -0,0 +1,36 @@
+# Running the RoboCode round-robin (Elo ranking)
+
+Rank the human bots in `configs/ablations/ladder/make_robocode.yaml` via all-pairs battles, then fit
+Elo. Each pair plays `sims_per_round` battle-rounds (the arena batches them `SIMS_PER_RUN=10` at a
+time, `sim_concurrency` in parallel). Battles are headless Java; cost is moderate — measure one pair
+first (below) to size the full run. Bots live on `CodeClash-ai/RoboCode` `human/*` branches;
+`branch_init` fetches them at runtime, so you only need this repo branch + Docker + a GitHub token.
+
+## Prerequisites
+- Docker running, git, `uv`, and a token for `CodeClash-ai/RoboCode` (public → `gh auth token`).
+
+## Step 0 — pre-build the arena image once (avoids a build stampede under -w N)
+```bash
+docker build -t codeclash/robocode -f codeclash/arenas/robocode/RoboCode.Dockerfile .
+```
+
+## Step 1 — round-robin
+`N` bots → `N*(N-1)/2` pairs. Keep `--workers ≈ cores-2`. Resumable (skips logged pairs).
+```bash
+GITHUB_TOKEN=$(gh auth token) \
+  uv run codeclash ladder make configs/ablations/ladder/make_robocode.yaml --workers 6
+```
+Tip: time one pair first to size the run — e.g. run a 2-player `codeclash run` config and note the
+wall time, then multiply by pair count / workers.
+
+## Step 2 — rank
+```bash
+python -m codeclash.analysis.metrics.elo -d logs/ladder/RoboCode --output-dir assets/robocode_elo
+```
+Prints the Bradley-Terry/Elo ordering and writes `assets/robocode_elo/elo_results.log`.
+
+## Step 3 — assemble the ladder configs (once you have the ranking)
+1. `configs/ablations/ladder/rungs/robocode.yaml` — ranked opponents, weakest first, strongest last.
+2. `configs/ablations/ladder/robocode.yaml` — climber `player` + `ladder: !include ablations/ladder/rungs/robocode.yaml`
+   + a `ladder_rules` block (model on `battlesnake.yaml`).
+3. Optional `robocode__<model>.yaml` per-model variants.