Merge branch 'main' into john/abclash

Author: john-b-yang

README.md

@@ -98,7 +98,11 @@ The winner is the LM agent who wins the most rounds.
 ## 🧩 Available Arenas
 
 CodeClash includes competitive programming games and simulation-backed arenas, including BattleSnake,
-CoreWar, CybORG, Halite, HuskyBench, RoboCode, RobotRumble, and SCML.
+Bomberland, CoreWar, CybORG, Halite, HuskyBench, RoboCode, RobotRumble, and SCML.
+
+Bomberland is a Bomberman-style grid arena based on Coder One's Bomberland competition. Agents edit
+a Python `bomberland_agent.py` implementation and compete to maximize average score across seeded
+simulations through survival, damage, kills, and destructible-block control.
 
 SCML is a supply-chain negotiation arena based on the ANAC Supply Chain Management League OneShot
 track. Agents edit a Python `scml_agent.py` implementation and compete to maximize average profit

codeclash/agents/player.py

@@ -35,6 +35,7 @@ def __init__(
             log_path=self.game_context.log_local / "players" / self.name / "player.log",
             emoji="👤",
         )
+        self._branch_name = config.get("branch", f"{self.game_context.id}.{self.name}")
         self._metadata = {
             "name": self.name,
             "player_unique_id": self._player_unique_id,
@@ -46,10 +47,6 @@ def __init__(
             "agent_stats": {},  # mapping round -> agent stats
         }
 
-        if branch := config.get("branch_init"):
-            self.logger.info(f"Checking out branch {branch}")
-            assert_zero_exit_code(self.environment.execute(f"git checkout {branch}"), logger=self.logger)
-
         if self.push:
             self.logger.info("Will push agent gameplay as branch to remote repository after each round")
             token = os.getenv("GITHUB_TOKEN")
@@ -61,6 +58,33 @@ def __init__(
             ]:
                 assert_zero_exit_code(self.environment.execute(cmd), logger=self.logger)
 
+        # Handle branch initialization
+        if branch_init := config.get("branch_init"):
+            # Fetch from remote first (handles branches pushed in previous tournaments)
+            # Then checkout - git will create tracking branch if needed
+            assert_zero_exit_code(
+                self.environment.execute(f"git fetch origin && git checkout {branch_init}"),
+                logger=self.logger,
+            )
+            self.logger.info(f"Checked out initial branch {branch_init}")
+
+        if self._branch_name != branch_init:
+            self.logger.info(f"Switching to branch {self._branch_name} for pushing changes")
+            # First fetch to see if the branch exists on remote
+            assert_zero_exit_code(
+                self.environment.execute("git fetch origin"),
+                logger=self.logger,
+            )
+            # Try to checkout the branch - git will track remote if it exists there
+            checkout_result = self.environment.execute(f"git checkout {self._branch_name}")
+            if checkout_result.get("returncode", 0) != 0:
+                # Branch doesn't exist locally or remotely, create it
+                self.logger.info(f"Branch {self._branch_name} doesn't exist, creating it")
+                assert_zero_exit_code(
+                    self.environment.execute(f"git checkout -b {self._branch_name}"),
+                    logger=self.logger,
+                )
+
     # --- Main methods ---
 
     def pre_run_hook(self, *, new_round: int) -> None:
@@ -104,7 +128,7 @@ def post_run_hook(self, *, round: int) -> None:
 
         if self.push:
             for cmd in [
-                f"git push origin {self._branch_name}",
+                f"git push -u origin {self._branch_name}",
                 "git push origin --tags",
             ]:
                 assert_zero_exit_code(self.environment.execute(cmd), logger=self.logger)
@@ -155,11 +179,6 @@ def _tag_round(self, round: int) -> None:
         )
         self._metadata["round_tags"][round] = tag
 
-    @property
-    def _branch_name(self) -> str:
-        """Get the branch name for the agent's codebase."""
-        return f"{self.game_context.id}.{self.name}"
-
     def _get_round_tag_name(self, round: int) -> str:
         """Get git tag name for the version of the codebase at the given round."""
         return f"{self._player_unique_id}-round-{round}"

codeclash/arenas/__init__.py

@@ -3,6 +3,7 @@
 from codeclash.arenas.battlecode24.battlecode24 import BattleCode24Arena
 from codeclash.arenas.battlecode25.battlecode25 import BattleCode25Arena
 from codeclash.arenas.battlesnake.battlesnake import BattleSnakeArena
+from codeclash.arenas.bomberland.bomberland import BomberlandArena
 from codeclash.arenas.bridge.bridge import BridgeArena
 from codeclash.arenas.chess.chess import ChessArena
 from codeclash.arenas.corewar.corewar import CoreWarArena
@@ -23,6 +24,7 @@
     BattleCode24Arena,
     BattleCode25Arena,
     BattleSnakeArena,
+    BomberlandArena,
     BridgeArena,
     ChessArena,
     CoreWarArena,

codeclash/arenas/bomberland/Bomberland.Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim-bookworm
+
+ARG BOMBERLAND_COMMIT=8b6b7a1c013d96feb0a5468a7a59a63a7c59dadc
+ENV BOMBERLAND_UPSTREAM_COMMIT=${BOMBERLAND_COMMIT}
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends git ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Keep a pinned copy of the upstream competition source for provenance and
+# agent authors who want to inspect the original starter-kit shape.
+RUN git clone https://github.com/CoderOneHQ/bomberland.git /opt/bomberland \
+    && cd /opt/bomberland \
+    && git checkout ${BOMBERLAND_COMMIT}
+
+WORKDIR /workspace
+COPY codeclash/arenas/bomberland/runtime/ /workspace/
+
+RUN git init \
+    && git config user.email "arena@codeclash.com" \
+    && git config user.name "CodeClash Arena" \
+    && git add . \
+    && git commit -m "Initialize Bomberland runtime"

codeclash/arenas/bomberland/__init__.py

@@ -0,0 +1,3 @@
+from codeclash.arenas.bomberland.bomberland import BomberlandArena
+
+__all__ = ["BomberlandArena"]

codeclash/arenas/bomberland/bomberland.py

@@ -0,0 +1,179 @@
+import json
+import shlex
+import subprocess
+
+from codeclash.agents.player import Player
+from codeclash.arenas.arena import CodeArena, RoundStats
+from codeclash.constants import RESULT_TIE
+from codeclash.utils.environment import assert_zero_exit_code
+
+RESULTS_JSON = "bomberland_results.json"
+CRASH_SCORE = -1_000_000.0
+
+
+class BomberlandArena(CodeArena):
+    name: str = "Bomberland"
+    submission: str = "bomberland_agent.py"
+    description: str = """Bomberland is a Bomberman-style multi-agent arena based on Coder One's Bomberland competition.
+
+Your bot is a Python file named `bomberland_agent.py` that defines a callable named `next_actions`.
+The callable receives a game-state dictionary and should return a dictionary mapping unit ids to actions:
+
+    def next_actions(game_state):
+        return {"unit_0": "up"}
+
+Valid actions are `up`, `down`, `left`, `right`, `bomb`, `stay`, and `detonate` (to blow up one of
+your own bombs early, e.g. the string `"detonate:x,y"` or `{"type": "detonate", "coordinates": [x, y]}`;
+bombs also explode automatically after their timer). Each round runs several deterministic seeded
+games. Your units move on a destructible grid, place bombs, destroy blocks, damage opposing units,
+and score by survival, damage, kills, and block destruction. Bomb blasts (`x` entities) stay active
+briefly and damage any unit standing on or moving into them.
+"""
+    default_args: dict = {
+        "sims_per_round": 4,
+        "ticks": 80,
+        "width": 11,
+        "height": 11,
+        "unit_count": 3,
+        "agent_timeout": 0.25,
+        "validation_timeout": 5,
+        "timeout": 180,
+    }
+
+    def __init__(self, config: dict, **kwargs):
+        player_count = len(config.get("players", []))
+        if player_count != 2:
+            raise ValueError("Bomberland requires exactly two players")
+        game_config = config.get("game", {})
+        game_args = game_config.get("args", {})
+        sims_per_round = int(
+            game_args.get("sims_per_round", game_config.get("sims_per_round", self.default_args["sims_per_round"]))
+        )
+        if sims_per_round % 2 != 0:
+            raise ValueError("Bomberland requires an even sims_per_round so both players get paired starting sides")
+        super().__init__(config, **kwargs)
+
+    def _game_arg(self, key: str):
+        nested_args = self.game_config.get("args", {})
+        return nested_args.get(key, self.game_config.get(key, self.default_args[key]))
+
+    def _sims_per_round(self) -> int:
+        return int(self._game_arg("sims_per_round"))
+
+    def validate_code(self, agent: Player) -> tuple[bool, str | None]:
+        quoted_submission = shlex.quote(self.submission)
+        file_check = agent.environment.execute(f"test -f {quoted_submission} && echo exists")
+        if "exists" not in file_check["output"]:
+            return False, f"Submission file `{self.submission}` not found in the workspace root"
+
+        content = agent.environment.execute(f"cat {quoted_submission}")["output"]
+        if not content.strip():
+            return False, f"`{self.submission}` is empty"
+
+        syntax_check = agent.environment.execute(f"python -m py_compile {quoted_submission}")
+        if syntax_check["returncode"] != 0:
+            return False, f"Python syntax error in `{self.submission}`:\n{syntax_check['output']}"
+
+        validation_timeout = int(self._game_arg("validation_timeout"))
+        try:
+            import_check = agent.environment.execute(
+                "python - <<'PY'\n"
+                "import importlib.util\n"
+                f"spec = importlib.util.spec_from_file_location('submission_agent', {self.submission!r})\n"
+                "module = importlib.util.module_from_spec(spec)\n"
+                "spec.loader.exec_module(module)\n"
+                "assert hasattr(module, 'next_actions'), 'next_actions callable not found'\n"
+                "assert callable(module.next_actions), 'next_actions must be callable'\n"
+                "state = {\n"
+                "    'connection': {'agent_id': 'Alice'},\n"
+                "    'agents': {'Alice': {'unit_ids': ['u0']}},\n"
+                "    'unit_state': {'u0': {'agent_id': 'Alice', 'hp': 3, 'coordinates': [1, 1]}},\n"
+                "    'entities': [],\n"
+                "    'world': {'width': 5, 'height': 5},\n"
+                "    'tick': 0,\n"
+                "}\n"
+                "result = module.next_actions(state)\n"
+                "assert result is None or isinstance(result, dict), 'next_actions must return a dict or None'\n"
+                "PY",
+                timeout=validation_timeout,
+            )
+        except subprocess.TimeoutExpired:
+            return False, f"`next_actions` validation exceeded {validation_timeout}s timeout"
+        if import_check["returncode"] != 0:
+            return False, f"Could not import or call `next_actions` from `{self.submission}`:\n{import_check['output']}"
+
+        return True, None
+
+    def execute_round(self, agents: list[Player]) -> None:
+        agent_args = []
+        for agent in agents:
+            agent_args.extend(["--agent", f"{agent.name}=/{agent.name}/{self.submission}"])
+
+        cmd = [
+            "python",
+            "run_bomberland.py",
+            "--sims",
+            str(self._sims_per_round()),
+            "--ticks",
+            str(self._game_arg("ticks")),
+            "--width",
+            str(self._game_arg("width")),
+            "--height",
+            str(self._game_arg("height")),
+            "--unit-count",
+            str(self._game_arg("unit_count")),
+            "--agent-timeout",
+            str(self._game_arg("agent_timeout")),
+            "--output",
+            str(self.log_env / RESULTS_JSON),
+            *agent_args,
+        ]
+        full_cmd = " ".join(shlex.quote(part) for part in cmd)
+        self.logger.info(f"Running game: {full_cmd}")
+        try:
+            response = self.environment.execute(full_cmd, timeout=int(self._game_arg("timeout")))
+        except subprocess.TimeoutExpired as exc:
+            raise RuntimeError("Bomberland round timed out") from exc
+        assert_zero_exit_code(response, logger=self.logger)
+
+    def get_results(self, agents: list[Player], round_num: int, stats: RoundStats):
+        result_file = self.log_round(round_num) / RESULTS_JSON
+        if not result_file.exists():
+            self.logger.error(f"Missing result file: {result_file}")
+            stats.winner = RESULT_TIE
+            for agent in agents:
+                stats.scores[agent.name] = CRASH_SCORE
+                stats.player_stats[agent.name].score = CRASH_SCORE
+                stats.details.append(
+                    json.dumps(
+                        {
+                            "player": agent.name,
+                            "score": CRASH_SCORE,
+                            "status": "error",
+                            "error": f"missing Bomberland result file: {result_file}",
+                        },
+                        sort_keys=True,
+                    )
+                )
+            return
+
+        with open(result_file) as f:
+            result = json.load(f)
+
+        scores = {agent.name: CRASH_SCORE for agent in agents}
+        for player, score in result.get("average_scores", {}).items():
+            if player in scores:
+                scores[player] = float(score)
+
+        stats.scores = scores
+        stats.details = result.get("details", [])
+        for player, score in scores.items():
+            stats.player_stats[player].score = score
+
+        if not scores:
+            stats.winner = RESULT_TIE
+            return
+
+        top_score = max(scores.values())
+        winners = [player for player, score in scores.items() if score == top_score]
+        stats.winner = winners[0] if len(winners) == 1 else RESULT_TIE

codeclash/arenas/bomberland/runtime/.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.pyc
+bomberland_results.json

codeclash/arenas/bomberland/runtime/README.md

@@ -0,0 +1,51 @@
+# Bomberland CodeClash Runtime
+
+This runtime adapts the Coder One Bomberland competition format into a compact,
+deterministic CodeClash arena. The Docker image keeps a pinned checkout of
+`CoderOneHQ/bomberland` at `/opt/bomberland` for provenance and starter-kit
+reference, while `run_bomberland.py` provides the runtime used by CodeClash.
+
+Submissions must provide `bomberland_agent.py` with:
+
+```python
+def next_actions(game_state):
+    return {"unit_0": "up"}
+```
+
+Valid string actions are `up`, `down`, `left`, `right`, `bomb`, `stay`, and
+`detonate` (blow up one of your own bombs early, e.g. `"detonate:x,y"` or
+`{"type": "detonate", "coordinates": [x, y]}`; bombs also explode on their timer).
+The game-state dictionary follows the upstream starter-kit shape where possible:
+`connection.agent_id` identifies the player, `agents[player].unit_ids` lists the
+controlled units, `unit_state` contains unit coordinates and health, and
+`entities` contains walls, destructible blocks, bombs, and blast tiles (`x`).
+Blast tiles stay active briefly and damage any unit that stands on or moves onto
+them, so avoid walking into fire.
+
+Round simulation counts must be even so each player receives both starting sides.
+
+Smoke command from the repository root:
+
+```bash
+uv run python main.py configs/examples/Bomberland__dummy__r1__s2.yaml -o /tmp/codeclash-bomberland-smoke
+```
+
+Use a fresh `-o` directory when rerunning the smoke check. Expected output:
+the command exits with status 0, both players pass validation, each round
+summary contains floating-point scores, and the output directory contains
+`metadata.json`, `game.log`, `tournament.log`, and compressed round logs.
+
+Expected result shape:
+
+```json
+{
+  "average_scores": {"player_a": 330.0, "player_b": 330.0},
+  "total_scores": {"player_a": 660.0, "player_b": 660.0},
+  "sims": 2,
+  "details": ["... per-simulation JSON strings ..."]
+}
+```
+
+Each detail entry is a JSON string with `scores`, `stats`, `alive_units`,
+`alive_hp`, `ticks`, and `winner` fields. Per-player `stats` include
+`agent_errors` and `invalid_actions`.

codeclash/arenas/bomberland/runtime/bomberland_agent.py

@@ -0,0 +1,5 @@
+def next_actions(game_state):
+    agent_id = game_state["connection"]["agent_id"]
+    unit_ids = game_state["agents"].get(agent_id, {}).get("unit_ids", [])
+    unit_state = game_state.get("unit_state", {})
+    return {unit_id: "stay" for unit_id in unit_ids if unit_state.get(unit_id, {}).get("hp", 0) > 0}