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

- 24 open-source classic Robocode bots imported to CodeClash-ai/RoboCode human/robocode/*
  branches (source of truth, not committed here): shipped sample bots + RoboWiki/PEZ
  micro-mini bots (Aristocles, Pugilist, HawkOnFire, ...) + single-file DrussGT (world-class
  top rung). Copy-in + rename to MyTank/package custom (classic robocode.* API, not Tank Royale).
  Each verified to COMPILE and play a real battle in the arena image (stage 2).
- Fix arena description: it mislabeled itself 'Tank Royale' but the engine is classic Robocode
  (extends robocode.Robot, javac against robocode.jar) — corrected so agents write the right API.
- configs/ablations/ladder/make_robocode.yaml: round-robin (100 rounds, ~5 min local) for Elo; README note.
- scripts/ladder/: build tooling adapted to Robocode (copy-in porting guide, structural validator,
  compile+battle smoke, push script, 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 24 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 lives 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,69 @@
+# Round-robin over the human classic-Robocode bots (imported from open-source repos: RoboWiki/PEZ
+# micro-mini bots, single-file DrussGT/HawkOnFire/WaveSurfing, and the shipped sample bots), used to
+# RANK them via Elo/Bradley-Terry -> see robocode.yaml for the ladder. rounds:0 = dummy players play
+# the baseline battles (no code edits). N bots -> N*(N-1)/2 pairs; each pair plays sims_per_round
+# battle-rounds (batched 10 at a time, sim_concurrency in 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, 24 bots -> 276 pairs
+# ~= 30 core-minutes -> ~5 min on a laptop (--workers 6). Robocode battles are cheap; 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/blackwidow
+- agent: dummy
+  branch_init: human/robocode/cham
+- agent: dummy
+  branch_init: human/robocode/corners
+- agent: dummy
+  branch_init: human/robocode/crazy
+- agent: dummy
+  branch_init: human/robocode/dacruzer
+- 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/gouldingi
+- agent: dummy
+  branch_init: human/robocode/hawkonfire
+- agent: dummy
+  branch_init: human/robocode/icarus
+- agent: dummy
+  branch_init: human/robocode/leach
+- agent: dummy
+  branch_init: human/robocode/littlebrother
+- agent: dummy
+  branch_init: human/robocode/mako
+- agent: dummy
+  branch_init: human/robocode/pugilist
+- agent: dummy
+  branch_init: human/robocode/ramfire
+- agent: dummy
+  branch_init: human/robocode/sittingduck
+- agent: dummy
+  branch_init: human/robocode/spinbot
+- 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/walls
+- 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.

scripts/ladder/examples/robots/custom/MyTank.java

@@ -0,0 +1,59 @@
+package custom;
+
+import robocode.AdvancedRobot;
+import robocode.ScannedRobotEvent;
+import robocode.HitByBulletEvent;
+import robocode.HitWallEvent;
+
+/**
+ * Reference bot for the CodeClash classic-Robocode arena contract and the porting example.
+ *
+ * The main class MUST be named MyTank and live in robots/custom/MyTank.java with `package custom;`.
+ * This is a simple AdvancedRobot: oscillate, spin the radar to keep a lock, and fire with power
+ * scaled to distance. Kept intentionally modest so it's a fair smoke-test opponent, not a wall.
+ */
+public class MyTank extends AdvancedRobot {
+    private int moveDirection = 1;
+
+    public void run() {
+        // Decouple gun+radar from the body so we can aim while moving.
+        setAdjustGunForRobotTurn(true);
+        setAdjustRadarForGunTurn(true);
+        while (true) {
+            setTurnRadarRight(360);
+            setAhead(120 * moveDirection);
+            setTurnRight(20);
+            execute();
+        }
+    }
+
+    public void onScannedRobot(ScannedRobotEvent e) {
+        double distance = e.getDistance();
+        double power = distance > 400 ? 1.0 : (distance > 200 ? 2.0 : 3.0);
+
+        // Simple head-on aim: turn gun toward the absolute bearing of the target.
+        double absoluteBearing = getHeading() + e.getBearing();
+        double gunTurn = absoluteBearing - getGunHeading();
+        setTurnGunRight(normalizeBearing(gunTurn));
+        if (Math.abs(gunTurn) < 10) {
+            setFire(power);
+        }
+        // Keep the radar locked on the target.
+        setTurnRadarRight(normalizeBearing(absoluteBearing - getRadarHeading()) * 2);
+    }
+
+    public void onHitByBullet(HitByBulletEvent e) {
+        moveDirection = -moveDirection;
+        setAhead(80 * moveDirection);
+    }
+
+    public void onHitWall(HitWallEvent e) {
+        moveDirection = -moveDirection;
+    }
+
+    private double normalizeBearing(double angle) {
+        while (angle > 180) angle -= 360;
+        while (angle < -180) angle += 360;
+        return angle;
+    }
+}

scripts/ladder/push_branches.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# Push every stage-2-healthy port to CodeClash-ai/RoboCode as a human/robocode/<slug> branch,
+# placing the port's .java files in the arena submission dir robots/custom/.
+# Port dir scripts/ladder/ports/<slug>/ -> branch human/robocode/<slug> with robots/custom/*.java.
+#   bash scripts/ladder/push_branches.sh
+set -euo pipefail
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+PORTS="$REPO_ROOT/scripts/ladder/ports"
+ARENA_REPO="CodeClash-ai/RoboCode"
+SKIP=""   # space-separated slugs to defer, if any
+
+TMP=$(mktemp -d)
+git clone -q "https://x-access-token:$(gh auth token)@github.com/${ARENA_REPO}.git" "$TMP"
+cd "$TMP"
+DEFAULT=$(git symbolic-ref --short HEAD)
+
+pushed=0; skipped=0
+PY="$(command -v python3 || command -v python)"
+OKS=$("$PY" -c "import json;d=json.load(open('$PORTS/_stage2.json'));print('\n'.join(k for k,v in sorted(d.items()) if v.get('ok')))")
+
+for slug in $OKS; do
+  case " $SKIP " in *" $slug "*) echo "SKIP  $slug (deferred)"; skipped=$((skipped+1)); continue;; esac
+  branch="human/robocode/$slug"
+  git checkout -q "$DEFAULT"
+  git checkout -q -B "$branch"
+  rm -rf robots/custom; mkdir -p robots/custom
+  cp "$PORTS/$slug/"*.java robots/custom/
+  git add robots/custom
+  git -c user.email=player@codeclash.com -c user.name="CodeClash" commit -qm "Import $slug (RoboCode ladder)"
+  git push -q -f -u origin "$branch" 2>/dev/null
+  echo "PUSH  $branch"
+  pushed=$((pushed+1))
+done
+cd "$REPO_ROOT"; rm -rf "$TMP"
+echo "=== pushed $pushed, skipped $skipped ==="