Class ChessArena

codeclash/arenas/chess/chess.py:16–526

class ChessArena(CodeArena):
    name: str = "Chess"
    description: str = """Chess is a strategic board game where you improve a chess engine (Kojiro) to compete against other engines.
Your engine is written in C++ and uses the UCI (Universal Chess Interface) protocol.
You can modify the evaluation function, search algorithms, move ordering, and other aspects of the engine to improve its strength.
The engine source code is located in the `src/` directory, and you compile it using `make native`.
IMPORTANT: Do not modify the executable name in the Makefile (keep `EXE = kojiro`). The executable must be named `kojiro`."""
    submission: str = "src/"
    default_args: dict = {
        "time_control": "1+0.01",
    }

    def __init__(self, config, **kwargs):
        super().__init__(config, **kwargs)

        # Get time control from config
        time_control = self.game_config.get("args", self.default_args).get(
            "time_control", self.default_args["time_control"]
        )

        # Build base Fastchess command
        self.run_cmd_base = f"fastchess -each tc={time_control}"

        # Store time control for reference
        self.time_control = time_control

        self.logger.debug(f"Initialized ChessArena with time control: {time_control}")

    def validate_code(self, agent: Player) -> tuple[bool, str | None]:
        """
        Validate that agent's Kojiro codebase compiles successfully.
        """
        # Check that src/ directory exists
        ls_result = agent.environment.execute("ls")
        if "src" not in ls_result["output"]:
            return False, "There should be a `src/` directory in the workspace"

        # Compile the engine
        self.logger.debug(f"Compiling Kojiro for agent {agent.name}")
        compile_result = agent.environment.execute(
            "cd src && make native",
            timeout=120,  # 2 minute timeout for compilation
        )

        if compile_result["returncode"] != 0:
            error_output = compile_result.get("output", "Unknown compilation error")
            # Truncate very long error messages
            if len(error_output) > 1000:
                error_output = error_output[:1000] + "\n... (truncated)"
            return False, f"Compilation failed:\n{error_output}"

        # Verify executable was created
        kojiro_check = agent.environment.execute("ls src/kojiro")
        if kojiro_check["returncode"] != 0 or "kojiro" not in kojiro_check["output"]:
            return False, "Compilation succeeded but executable 'kojiro' not found in src/"

        self.logger.info(f"Agent {agent.name} passed validation: Kojiro compiles successfully")
        return True, None