Merge branch 'main' into add-uv

Author: john-b-yang

codeclash/analysis/matrix.py

@@ -8,7 +8,7 @@
 
 from codeclash.agents.dummy_agent import Dummy
 from codeclash.agents.utils import GameContext
-from codeclash.arenas import get_game
+from codeclash.arenas import get_arena
 from codeclash.constants import DIR_WORK
 from codeclash.tournaments.utils.git_utils import filter_git_diff
 from codeclash.utils.atomic_write import atomic_write
@@ -109,7 +109,7 @@ def _initialize_game_pool(self):
             config = self.config.copy()
             config["game"]["sims_per_round"] = self.n_repetitions
 
-            game = get_game(
+            game = get_arena(
                 config,
                 tournament_id=tournament_id,
                 local_output_dir=self.pvp_output_dir / "matrix_eval" / f"worker_{i}",

codeclash/arenas/__init__.py

@@ -4,9 +4,8 @@
 from codeclash.arenas.corewar.corewar import CoreWarArena
 from codeclash.arenas.dummy.dummy import DummyArena
 from codeclash.arenas.halite.halite import HaliteArena
-
-# from codeclash.games.halite2.halite2 import Halite2Game # WIP
-# from codeclash.games.halite3.halite3 import Halite3Game # WIP
+from codeclash.arenas.halite2.halite2 import Halite2Arena
+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
@@ -17,14 +16,16 @@
     CoreWarArena,
     DummyArena,
     HaliteArena,
+    Halite2Arena,
+    Halite3Arena,
     HuskyBenchArena,
     RoboCodeArena,
     RobotRumbleArena,
 ]
 
 
 # might consider postponing imports to avoid loading things we don't need
-def get_game(config: dict, **kwargs) -> CodeArena:
+def get_arena(config: dict, **kwargs) -> CodeArena:
     game = {x.name: x for x in ARENAS}.get(config["game"]["name"])
     if game is None:
         raise ValueError(f"Unknown game: {config['game']['name']}")

codeclash/arenas/halite/halite.py

@@ -13,11 +13,13 @@
 
 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 = {
-    ".cpp": "g++ -std=c++11 {path}.cpp -o {name}.o",
-    ".c": "gcc {path}.c -o {name}.o",
+    ".cpp": "g++ -std=c++11 {name}.cpp -o {name}.o",
+    ".c": "gcc {name}.c -o {name}.o",
+    ".hs": "ghc --make {name}.hs -O -v0 -rtsopts -outputdir dist",
     ".ml": "ocamlbuild -lib unix {name}.native",
     ".rs": "cargo build",
 }
@@ -26,6 +28,7 @@
 MAP_FILE_TYPE_TO_RUN = {
     ".c": "{path}/{name}.o",
     ".cpp": "{path}/{name}.o",
+    ".hs": "{path}/{name}",
     ".js": "node {path}/{name}.js",
     ".ml": "{path}/{name}.native",
     ".py": "python {path}/{name}.py",
@@ -50,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:
@@ -91,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:
@@ -120,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(path="main", 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:
@@ -157,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:
@@ -167,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

…lash/arenas/halite2/Halite-II.Dockerfile …eclash/arenas/halite2/Halite2.Dockerfilecodeclash/arenas/halite2/Halite-II.Dockerfile renamed to codeclash/arenas/halite2/Halite2.Dockerfile codeclash/arenas/halite2/Halite-II.Dockerfile renamed to codeclash/arenas/halite2/Halite2.Dockerfile

@@ -18,11 +18,24 @@ ENV PATH="/root/.cargo/bin:${PATH}"
 # Install ocaml
 RUN apt-get update && apt-get install -y ocaml ocamlbuild
 
+# Install Haskell
+RUN apt-get update && apt-get install -y libgmp-dev \
+ && rm -rf /var/lib/apt/lists/*
+
+# Install GHCup non-interactively
+RUN curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | \
+    BOOTSTRAP_HASKELL_NONINTERACTIVE=1 BOOTSTRAP_HASKELL_ADJUST_BASHRC=1 sh
+
+# Add ghcup to PATH
+ENV PATH="/root/.ghcup/bin:${PATH}"
+
+# Verify installation
+RUN ghc --version && cabal --version
+
 # Clone Halite repository
-RUN git clone https://github.com/CodeClash-ai/Halite-II.git /workspace \
+RUN git clone https://github.com/CodeClash-ai/Halite2.git /workspace \
     && cd /workspace \
-    && git remote set-url origin https://github.com/CodeClash-ai/Halite-II.git \
-
+    && git remote set-url origin https://github.com/CodeClash-ai/Halite2.git
 WORKDIR /workspace
 
 RUN cd environment && cmake . && make

codeclash/arenas/halite2/halite2.py

@@ -2,7 +2,17 @@
 
 
 class Halite2Arena(HaliteArena):
-    name: str = "Halite-II"
-    description: str = ""
-    default_args: dict = {}
-    submission: str = "submission"
+    name: str = "Halite2"
+    description: str = """Halite II is a multi-player AI-programming challenge in which bots pilot fleets of spaceships across a continuous space-themed universe.
+Players command ships to mine planets for halite, use that resource to build additional ships, and expand control across the map.
+Victory depends on efficient resource gathering, fleet management, and strategic expansion to outcompete rival bots for dominance.
+
+You have the choice of writing your Halite bot in one of four programming languages: C++, Haskell, 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 OCaml 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.
+"""

…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,
+        )

codeclash/tournaments/pvp.py

@@ -11,7 +11,7 @@
 from codeclash.agents import get_agent
 from codeclash.agents.player import Player
 from codeclash.agents.utils import GameContext
-from codeclash.arenas import get_game
+from codeclash.arenas import get_arena
 from codeclash.arenas.arena import CodeArena
 from codeclash.constants import DIR_LOGS, DIR_WORK, FILE_RESULTS, OPPONENT_CODEBASES_DIR_NAME
 from codeclash.tournaments.tournament import AbstractTournament
@@ -35,7 +35,7 @@ def __init__(
             self.logger.critical(f"Metadata file already exists: {self.metadata_file}")
             raise FileExistsError(f"Metadata file already exists: {self.metadata_file}")
         self.cleanup_on_end = cleanup
-        self.game: CodeArena = get_game(
+        self.game: CodeArena = get_arena(
             self.config,
             tournament_id=self.tournament_id,
             local_output_dir=self.local_output_dir,

codeclash/tournaments/single_player.py

@@ -10,7 +10,7 @@
 from codeclash.agents.dummy_agent import Dummy
 from codeclash.agents.player import Player
 from codeclash.agents.utils import GameContext
-from codeclash.arenas import get_game
+from codeclash.arenas import get_arena
 from codeclash.arenas.arena import CodeArena
 from codeclash.constants import DIR_WORK, FILE_RESULTS
 from codeclash.tournaments.tournament import AbstractTournament
@@ -24,7 +24,7 @@ class SinglePlayerTraining(AbstractTournament):
     def __init__(self, config: dict, *, output_dir: Path, cleanup: bool = False, keep_containers: bool = False):
         super().__init__(config, name="SinglePlayerTraining", output_dir=output_dir)
         self.cleanup_on_end = cleanup
-        self.game: CodeArena = get_game(
+        self.game: CodeArena = get_arena(
             self.config,
             tournament_id=self.tournament_id,
             local_output_dir=self.local_output_dir,

configs/test/halite2.yaml

@@ -1,7 +1,7 @@
 tournament:
   rounds: 3
 game:
-  name: Halite-II
+  name: Halite2
   sims_per_round: 250
 players:
 - agent: dummy
@@ -10,9 +10,10 @@ players:
   name: p2
 prompts:
   game_description: |
-    You are a software developer ({{player_id}}) competing in an arena called Halite.
-    In this game, you will write code to control ships that gather resources, build structures, and compete for dominance on a grid-based map.
-    Victory is achieved by outmaneuvering opponents, optimizing resource collection, and strategically expanding your territory.
+    You are a software developer ({{player_id}}) competing in an arena called Halite2.
+    In this game, you will write code to control fleets of spaceships across a continuous space-themed universe.
+    Players command ships to mine planets for halite, use that resource to build additional ships, and expand control across the map.
+    Victory depends on efficient resource gathering, fleet management, and strategic expansion to outcompete rival bots for dominance.
 
     The game is played in {{rounds}} rounds. For every round, you (and your competitor) edit program code that controls your bot. This is round {{round}}.
     After you and your competitor finish editing your codebases, the game is run automatically.