Class HaliteArena

codeclash/arenas/halite/halite.py:42–199

class HaliteArena(CodeArena):
    name: str = "Halite"
    description: str = """Halite is a multi-player turn-based strategy game where bots compete on a rectangular grid to capture territory and accumulate strength.
Players control pieces that can move across the map to conquer neutral and enemy territory, with each cell providing production that increases the strength of pieces occupying it.
The goal is to control the most territory by the end of the game through strategic expansion, consolidation of forces, and tactical combat decisions.

You have the choice of writing your Halite bot in one of four programming languages: C, C++, OCaml, or Rust.
Example implementations can be found under the `airesources/` folder.
Your submission should be stored in the `submission/` folder. This folder currently contains an example C bot, but feel free to use any of the supported languages.
Please make sure your main file is named `main.<ext>`, where `<ext>` is the appropriate file extension for your chosen programming language.
You may include additional files as needed, but please ensure:
1. The `submission/` folder contains only files relevant to your bot.
2. The `submission/` folder ONLY contains a single bot (no multiple bots in one submission).
3. Your bot can be compiled. See `runGame.sh` under the corresponding `submission/<language>/` folder to see how we will compile and run your bot.
"""
    default_args: dict = {}
    submission: str = "submission"
    executable: str = "./environment/halite"

    def __init__(self, config, **kwargs):
        super().__init__(config, **kwargs)
        self.run_cmd_round: str = f"{self.executable} --replaydirectory {self.log_env}"
        for arg, val in self.game_config.get("args", self.default_args).items():
            if isinstance(val, bool):
                if val:
                    self.run_cmd_round += f" --{arg}"
            else:
                self.run_cmd_round += f" --{arg} {val}"

    def _run_single_simulation(self, agents: list[Player], idx: int, cmd: str):
        """Run a single halite simulation and return the output."""
        cmd = f"{cmd} > {self.log_env / HALITE_LOG.format(idx=idx)}"

        # Run the simulation and return the output
        try:
            response = self.environment.execute(cmd, timeout=120)
        except subprocess.TimeoutExpired:
            self.logger.warning(f"Halite simulation {idx} timed out: {cmd}")
            return
        if response["returncode"] != 0:
            self.logger.warning(
                f"Halite simulation {idx} failed with exit code {response['returncode']}:\n{response['output']}"
            )

    def execute_round(self, agents: list[Player]):
        entries = []
        for agent in agents:
            executable = agent.environment.execute(f"cat {HALITE_HIDDEN_EXEC}")["output"].strip()
            entries.append(executable)
        cmd = f"{self.run_cmd_round} {shlex.join(entries)}"
        self.logger.info(f"Running game: {cmd}")
        with ThreadPoolExecutor(self.game_config.get("sim_concurrency", 20)) as executor:
            futures = [
                executor.submit(self._run_single_simulation, agents, idx, cmd)
                for idx in range(self.game_config["sims_per_round"])
            ]
            for future in tqdm(as_completed(futures), total=len(futures)):
                future.result()