Add Halite III

Author: john-b-yang

codeclash/arenas/__init__.py

@@ -5,8 +5,7 @@
 from codeclash.arenas.dummy.dummy import DummyArena
 from codeclash.arenas.halite.halite import HaliteArena
 from codeclash.arenas.halite2.halite2 import Halite2Arena
-
-# from codeclash.games.halite3.halite3 import Halite3Game # WIP
+from codeclash.arenas.halite3.halite3 import Halite3Arena
 from codeclash.arenas.huskybench.huskybench import HuskyBenchArena
 from codeclash.arenas.robocode.robocode import RoboCodeArena
 from codeclash.arenas.robotrumble.robotrumble import RobotRumbleArena
@@ -18,6 +17,7 @@
     DummyArena,
     HaliteArena,
     Halite2Arena,
+    Halite3Arena,
     HuskyBenchArena,
     RoboCodeArena,
     RobotRumbleArena,

codeclash/arenas/halite/halite.py

@@ -13,6 +13,7 @@
 
 HALITE_LOG = "sim_{idx}.log"
 HALITE_HIDDEN_EXEC = ".codeclash_exec"
+HALITE_WIN_PATTERN = r"Player\s#(\d+),\s(.*),\scame\sin\srank\s#(\d+)"
 
 # Command to be run in each agent's `submission/` folder to compile agent
 MAP_FILE_TYPE_TO_COMPILE = {
@@ -52,10 +53,11 @@ class HaliteArena(CodeArena):
 """
     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"./environment/halite --replaydirectory {self.log_env}"
+        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:
@@ -93,13 +95,18 @@ def execute_round(self, agents: list[Player]):
             for future in tqdm(as_completed(futures), total=len(futures)):
                 future.result()
 
-    def get_results(self, agents: list[Player], round_num: int, stats: RoundStats):
+    def get_results(
+        self,
+        agents: list[Player],
+        round_num: int,
+        stats: RoundStats,
+        pattern: str = HALITE_WIN_PATTERN,
+    ):
         winners = []
-        pattern = r"Player\s#(\d+),\s(.*),\scame\sin\srank\s#(\d+)"
         for idx in range(self.game_config["sims_per_round"]):
             log_file = self.log_round(round_num) / HALITE_LOG.format(idx=idx)
             with open(log_file) as f:
-                lines = f.readlines()[-len(agents) - 1 :]
+                lines = f.readlines()[-len(agents) - 5 :]
                 for line in lines:
                     match = re.search(pattern, line)
                     if match:
@@ -122,32 +129,47 @@ def get_results(self, agents: list[Player], round_num: int, stats: RoundStats):
             if player != RESULT_TIE:
                 stats.player_stats[player].score = score
 
-    def validate_code(self, agent: Player) -> tuple[bool, str | None]:
+    def validate_code(
+        self,
+        agent: Player,
+        map_file_type_to_compile: dict = MAP_FILE_TYPE_TO_COMPILE,
+        map_file_type_to_run: dict = MAP_FILE_TYPE_TO_RUN,
+    ) -> tuple[bool, str | None]:
         # Check that the `submission/` folder exists
         exists_output = agent.environment.execute("test -d submission && echo 'exists'")["output"]
         if "exists" != exists_output.strip():
             return False, f"Submission folder `{self.submission}/` does not exist"
 
         # Check that there is a *single* file called "main.<ext>" in the submission folder
         # and that <ext> is one of the supported file types
+        found_main = False
         sub_path = Path(agent.environment.config.cwd) / self.submission
-        ls_output = agent.environment.execute("ls", cwd=sub_path)["output"]
+        ls_output = agent.environment.execute("ls", cwd=sub_path)["output"].splitlines()
         main_files = [
-            fname
-            for fname in ls_output.splitlines()
-            if fname.startswith("main.") and Path(fname).suffix in MAP_FILE_TYPE_TO_RUN
+            fname for fname in ls_output if fname.startswith("main.") and Path(fname).suffix in map_file_type_to_run
         ]
-        supported_exts = "|".join(MAP_FILE_TYPE_TO_RUN.keys())
+
         if len(main_files) != 1:
+            # Check if src/main.rs exists for Rust projects
+            if "src" in ls_output:
+                src_ls_output = agent.environment.execute("ls src", cwd=sub_path)["output"].splitlines()
+                if "main.rs" in src_ls_output:
+                    main_files = ["src/main.rs"]
+                    found_main = True
+        else:
+            found_main = True
+
+        if not found_main:
+            supported_exts = "|".join(map_file_type_to_run.keys())
             return (
                 False,
                 f"Exactly one main.[{supported_exts}] file must be present in submission, found {len(main_files)}",
             )
         main_ext = Path(main_files[0]).suffix
 
         # Check that the submission compiles if necessary
-        if main_ext in MAP_FILE_TYPE_TO_COMPILE:
-            compile_cmd = MAP_FILE_TYPE_TO_COMPILE[main_ext].format(name="main")
+        if main_ext in map_file_type_to_compile:
+            compile_cmd = map_file_type_to_compile[main_ext].format(name="main")
             try:
                 compile_response = agent.environment.execute(compile_cmd, timeout=15, cwd=sub_path)
             except subprocess.TimeoutExpired:
@@ -159,8 +181,8 @@ def validate_code(self, agent: Player) -> tuple[bool, str | None]:
                 )
 
         # Check that submission runs in competition
-        executable = MAP_FILE_TYPE_TO_RUN[main_ext].format(path=self.submission, name="main")
-        run_cmd = f"./environment/halite {shlex.join([executable, executable])}"
+        executable = map_file_type_to_run[main_ext].format(path=self.submission, name="main")
+        run_cmd = f"{self.executable} {shlex.join([executable, executable])}"
         try:
             run_response = agent.environment.execute(run_cmd, timeout=15)
         except subprocess.TimeoutExpired:
@@ -169,6 +191,6 @@ def validate_code(self, agent: Player) -> tuple[bool, str | None]:
             return False, f"Submission failed to run (ran {run_cmd}): {run_response['output']}"
 
         # Record command to run executable to hidden file
-        executable_comp = MAP_FILE_TYPE_TO_RUN[main_ext].format(path=f"/{agent.name}/{self.submission}", name="main")
+        executable_comp = map_file_type_to_run[main_ext].format(path=f"/{agent.name}/{self.submission}", name="main")
         agent.environment.execute(f'echo "{executable_comp}" > {HALITE_HIDDEN_EXEC}')
         return True, None

…ash/arenas/halite3/Halite-III.Dockerfile …eclash/arenas/halite3/Halite3.Dockerfilecodeclash/arenas/halite3/Halite-III.Dockerfile renamed to codeclash/arenas/halite3/Halite3.Dockerfile codeclash/arenas/halite3/Halite-III.Dockerfile renamed to codeclash/arenas/halite3/Halite3.Dockerfile

@@ -19,9 +19,9 @@ ENV PATH="/root/.cargo/bin:${PATH}"
 RUN apt-get update && apt-get install -y ocaml ocamlbuild
 
 # Clone Halite repository
-RUN git clone https://github.com/CodeClash-ai/Halite-III.git /workspace \
+RUN git clone https://github.com/CodeClash-ai/Halite3.git /workspace \
     && cd /workspace \
-    && git remote set-url origin https://github.com/CodeClash-ai/Halite-III.git
+    && git remote set-url origin https://github.com/CodeClash-ai/Halite3.git
 WORKDIR /workspace
 
 RUN cd game_engine && cmake . && make

codeclash/arenas/halite3/halite3.py

@@ -1,8 +1,68 @@
-from codeclash.arenas.halite.halite import HaliteArena
+import subprocess
+
+from codeclash.agents.player import Player
+from codeclash.arenas.arena import RoundStats
+from codeclash.arenas.halite.halite import HALITE_LOG, HaliteArena
+
+HALITE_WIN_PATTERN = r"Player\s(\d+),\s'(\S+)',\swas\srank\s(\d+)"
+
+# Command to be run in each agent's `submission/` folder to compile agent
+MAP_FILE_TYPE_TO_COMPILE = {
+    ".cpp": "cmake . && make",
+    ".ml": "ocamlbuild -lib unix {name}.native",
+    ".rs": "cargo build",
+}
+
+# Command to be run from `environment/` folder to run competition
+MAP_FILE_TYPE_TO_RUN = {
+    ".cpp": "{path}/{name}",
+    ".ml": "{path}/{name}.native",
+    ".rs": "{path}/target/debug/{name}",
+}
 
 
 class Halite3Arena(HaliteArena):
-    name: str = "Halite-III"
-    description: str = ""
+    name: str = "Halite3"
+    description: str = """"""
     default_args: dict = {}
     submission: str = "submission"
+    executable: str = "./game_engine/halite"
+
+    def __init__(self, config, **kwargs):
+        super().__init__(config, **kwargs)
+        # Remove replaydirectory arg as Halite3 does not support it
+        self.run_cmd_round: str = self.run_cmd_round.replace(f"--replaydirectory {self.log_env}", "")
+
+    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)} 2>&1"
+
+        # Run the simulation and return the output
+        try:
+            response = self.environment.execute(cmd, timeout=120)
+            self.environment.execute(f"mv errorlog*.log {self.log_env}", timeout=10)
+        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 get_results(self, agents: list[Player], round_num: int, stats: RoundStats):
+        return super().get_results(
+            agents,
+            round_num,
+            stats,
+            pattern=HALITE_WIN_PATTERN,
+        )
+
+    def validate_code(
+        self,
+        agent: Player,
+    ):
+        return super().validate_code(
+            agent,
+            MAP_FILE_TYPE_TO_COMPILE,
+            MAP_FILE_TYPE_TO_RUN,
+        )

configs/test/halite2.yaml

@@ -1,7 +1,7 @@
 tournament:
   rounds: 3
 game:
-  name: Halite-II
+  name: Halite2
   sims_per_round: 250
 players:
 - agent: dummy

configs/test/halite3.yaml

@@ -1,7 +1,7 @@
 tournament:
   rounds: 3
 game:
-  name: Halite-III
+  name: Halite3
   sims_per_round: 250
 players:
 - agent: dummy