Fix ladder player names for RoboCode; bump make_robocode sims to 300

`ladder make` set the per-player name to the raw branch_init (e.g.
`human/robocode/walls`), which the RoboCode arena turns into an on-disk dir,
a Java package via `sed s/custom/<name>/`, and a robot-selector token. Slashes
broke the sed (terminating the s/// command) and produced invalid robot names,
so battles loaded 0 robots and get_results crashed on max() of an empty score
dict. Sanitizing to `robocode_<bot>` still failed: RoboCode reserves the
`robocode` package namespace for its engine, so its robot classloader refuses
any robot whose package starts with it (ClassNotFoundException at battle time).

Add `_player_slug()` (shared by make + run) that strips the `human/` prefix and
a leading path segment equal to the game name, yielding a bare `<bot>` package
(e.g. `human/robocode/walls` -> `walls`). Non-RoboCode branches
(`human/<author>/<bot>`, `human/<bot>`) are unaffected -- their leading segment
never matches the game name, so slugs are identical to before.

Bump make_robocode.yaml sims_per_round 100 -> 300 for lower Elo variance
(~41s/pair solo, ~25s/pair throughput under -w 6; still far under the 5-min/pair
budget) and refresh the cost comment with measured numbers.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: john-b-yang

codeclash/cli/ladder.py

@@ -18,6 +18,27 @@
 logger = get_logger("ladder")
 
 
+def _player_slug(branch_init: str, game_name: str) -> str:
+    """Turn a ``human/<...>/<bot>`` init branch into a bare, package-safe player name.
+
+    The name is used as an on-disk directory and — in the RoboCode arena — as a Java package name
+    and robot-selector token (``robots/<name>/``, ``sed s/custom/<name>/``,
+    ``selectedRobots=<name>.MyTank``), so it must contain no slashes. RoboCode additionally reserves
+    the ``robocode`` package namespace for its engine and its robot classloader refuses to load any
+    robot whose package starts with it, so a leading path segment equal to the game name (RoboCode
+    branches are ``human/robocode/<bot>``) is dropped rather than folded into a ``robocode_<bot>``
+    token that would raise ClassNotFoundException at battle time. Non-RoboCode branches
+    (``human/<author>/<bot>``, ``human/<bot>``) are unaffected: their leading segment never matches
+    the game name, so the result is the same ``<author>_<bot>`` slug as before.
+    """
+    parts = [p for p in branch_init.split("/") if p]
+    if parts and parts[0] == "human":
+        parts = parts[1:]
+    if parts and parts[0].lower() == game_name.lower():
+        parts = parts[1:]
+    return "_".join(parts)
+
+
 def _resolve_ladder_rules(ladder_rules: dict, rounds: int) -> tuple[float, int]:
     """Validate the optional ``ladder_rules`` block and return ``(min_round_win_fraction, win_last_k)``.
 
@@ -83,15 +104,17 @@ def make(
     players = config["players"]
     num_players = len(players)
 
+    game_name = config["game"]["name"]
+
     # Build one fully independent (deep-copied) config per pair up front so concurrent runs
     # never share or mutate the same player/config dicts.
     jobs: list[tuple[dict, Path]] = []
     for i in range(num_players):
         for j in range(i + 1, num_players):
             player1 = copy.deepcopy(players[i])
-            player1["name"] = player1["branch_init"]
+            player1["name"] = _player_slug(player1["branch_init"], game_name)
             player2 = copy.deepcopy(players[j])
-            player2["name"] = player2["branch_init"]
+            player2["name"] = _player_slug(player2["branch_init"], game_name)
             pvp_config = {**copy.deepcopy(config), "players": [player1, player2]}
             vs = f"PvpTournament.{player1['name']}_vs_{player2['name']}".replace("/", "_")
             output_dir = LOCAL_LOG_DIR / "ladder" / config["game"]["name"] / vs
@@ -157,7 +180,7 @@ def run(
 
     for idx, opponent in enumerate(ladder):
         opponent_rank = len(ladder) - idx
-        opponent["name"] = opponent["branch_init"].replace("human/", "").replace("/", "_")
+        opponent["name"] = _player_slug(opponent["branch_init"], config["game"]["name"])
         if "branch_init" in player and idx > 0:
             # After first opponent, remove branch_init so that player continues from previous tournament's codebase
             del player["branch_init"]

configs/ablations/ladder/make_robocode.yaml

@@ -3,14 +3,16 @@
 # 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, 116 bots -> 6670 pairs
-# ~= 13 core-hours -> ~2 h on a laptop (--workers 6), ~26 min on a 32-core box (-w 30).
+# COST (measured on an 8-core box: a pair is ~11.8s fixed overhead + ~9.7s per 100 sims, so at
+# sims_per_round=300 a single pair is ~41s solo and ~25s/pair of throughput under --workers 6).
+# 116 bots -> 6670 pairs -> ~46 core-hours -> ~2 days on an 8-core box (-w 6). Resumable: skips
+# already-logged pairs, so a killed run can be re-launched. Scale --workers with cores (~cores-2).
 # Run: uv run codeclash ladder make configs/ablations/ladder/make_robocode.yaml --workers 6
 tournament:
   rounds: 0
 game:
   name: RoboCode
-  sims_per_round: 100
+  sims_per_round: 300
   sim_concurrency: 5
   args:
     nodisplay: true