Add working Halite

Author: john-b-yang

codeclash/games/halite/halite.py

@@ -3,6 +3,7 @@
 import subprocess
 from collections import Counter
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
 
 from tqdm.auto import tqdm
 
@@ -11,12 +12,43 @@
 from codeclash.games.game import CodeGame, RoundStats
 
 HALITE_LOG = "sim_{idx}.log"
+HALITE_SUBMISSION = "submission"
+HALITE_HIDDEN_EXEC = ".codeclash_exec"
+
+# 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",
+    ".ml": "ocamlbuild -lib unix {name}.native",
+    ".rs": "cargo build",
+}
+
+# Command to be run from `environment/` folder to run competition
+MAP_FILE_TYPE_TO_RUN = {
+    ".c": "{path}/{name}.o",
+    ".cpp": "{path}/{name}.o",
+    ".js": "node {path}/{name}.js",
+    ".ml": "{path}/{name}.native",
+    ".py": "python {path}/{name}.py",
+    ".rs": "{path}/target/debug/{name}",
+}
 
 
 class HaliteGame(CodeGame):
     name: str = "Halite"
-    description: str = """Halite is a strategic programming game where players write bots 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"""
+    description: str = f"""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 `{HALITE_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 = {}
 
     def __init__(self, config, **kwargs):
@@ -47,10 +79,11 @@ def _run_single_simulation(self, agents: list[Player], idx: int, cmd: str):
     def execute_round(self, agents: list[Player]):
         entries = []
         for agent in agents:
-            entries.append(f"python /{agent.name}/airesources/Python/RandomBot.py")
+            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(5) as executor:
+        with ThreadPoolExecutor(20) as executor:
             futures = [
                 executor.submit(self._run_single_simulation, agents, idx, cmd)
                 for idx in range(self.game_config["sims_per_round"])
@@ -88,4 +121,47 @@ def get_results(self, agents: list[Player], round_num: int, stats: RoundStats):
                 stats.player_stats[player].score = score
 
     def validate_code(self, agent: Player) -> tuple[bool, str | None]:
+        # Check that there is a *single* file called "main.<ext>" in the submission folder
+        # and that <ext> is one of the supported file types
+        sub_path = Path(agent.environment.config.cwd) / HALITE_SUBMISSION
+        ls_output = agent.environment.execute("ls", cwd=sub_path)["output"]
+        main_files = [
+            fname
+            for fname in ls_output.splitlines()
+            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:
+            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")
+            try:
+                compile_response = agent.environment.execute(compile_cmd, timeout=15, cwd=sub_path)
+            except subprocess.TimeoutExpired:
+                return False, f"Compilation failed (ran {compile_cmd} inside {HALITE_SUBMISSION}): timed out"
+            if compile_response["returncode"] != 0:
+                return (
+                    False,
+                    f"Compilation failed (ran {compile_cmd} inside {HALITE_SUBMISSION}): {compile_response['output']}",
+                )
+
+        # Check that submission runs in competition
+        executable = MAP_FILE_TYPE_TO_RUN[main_ext].format(path=HALITE_SUBMISSION, name="main")
+        run_cmd = f"./environment/halite {shlex.join([executable, executable])}"
+        try:
+            run_response = agent.environment.execute(run_cmd, timeout=15)
+        except subprocess.TimeoutExpired:
+            return False, f"Submission failed to run (ran {run_cmd}): timed out"
+        if run_response["returncode"] != 0:
+            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}/{HALITE_SUBMISSION}", name="main")
+        agent.environment.execute(f'echo "{executable_comp}" > {HALITE_HIDDEN_EXEC}')
         return True, None

configs/test/players/2/halite.yaml

@@ -1,8 +1,8 @@
 tournament:
-  rounds: 1
+  rounds: 3
 game:
   name: Halite
-  sims_per_round: 10
+  sims_per_round: 250
 players:
 - agent: dummy
   name: p1

configs/test/players/4/halite.yaml

@@ -0,0 +1,25 @@
+tournament:
+  rounds: 3
+game:
+  name: Halite
+  sims_per_round: 10
+players:
+- agent: dummy
+  name: p1
+- agent: dummy
+  name: p2
+- agent: dummy
+  name: p3
+- agent: dummy
+  name: p4
+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.
+
+    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.
+
+    Your task: improve the bot, located in {{working_dir}}.
+    {{working_dir}} is your codebase, which contains both your bot and supporting assets.

docker/Halite.Dockerfile

@@ -9,6 +9,16 @@ RUN apt-get update \
     python3-pip python-is-python3 wget git build-essential jq curl locales \
  && rm -rf /var/lib/apt/lists/*
 
+# Install Rust via rustup
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y \
+    && . "$HOME/.cargo/env" \
+    && echo 'source $HOME/.cargo/env' >> /etc/bash.bashrc
+ENV PATH="/root/.cargo/bin:${PATH}"
+
+# Install ocaml
+RUN apt-get update && apt-get install -y ocaml ocamlbuild
+
+# Clone Halite repository
 ARG GITHUB_TOKEN
 RUN git clone https://${GITHUB_TOKEN}@github.com/emagedoc/Halite.git /workspace \
     && cd /workspace \