Add Halite3 assets; RobotRumble supports python

Author: john-b-yang

codeclash/agents/player.py

@@ -47,6 +47,10 @@ def __init__(
             "agent_stats": {},  # mapping round -> agent stats
         }
 
+        if "branch_init" in config:
+            self.logger.info(f"Initializing codebase from branch {config['branch_init']}")
+            assert_zero_exit_code(self.environment.execute(f"git checkout {config['branch_init']}"), logger=self.logger)
+
         if self.push:
             self.logger.info("Will push agent gameplay as branch to remote repository after each round")
             token = os.getenv("GITHUB_TOKEN")

codeclash/analysis/transparent/main.py

@@ -131,6 +131,7 @@ def analyze_temporal_opponent_access(folder_list):
 
 
 if __name__ == "__main__":
+    # `normal` is all 1v1 Halite games from main results
     normal = sorted(
         [
             x.parent

codeclash/analysis/viz/heatmap_win_rates.py

@@ -68,6 +68,13 @@ def main(log_dir: Path, unit: str = "rounds", output_file: Path = ASSETS_DIR / "
             if i != j and results[(m1, m2)][1] > 0:
                 matrix[i, j] = results[(m1, m2)][0] / results[(m1, m2)][1]
 
+    # Print out average win rate per model
+    for m1 in models:
+        total_wins = sum(results[(m1, m2)][0] for m2 in models if m1 != m2)
+        total_matches = sum(results[(m1, m2)][1] for m2 in models if m1 != m2)
+        avg_win_rate = total_wins / total_matches if total_matches > 0 else 0
+        print(f"{MODEL_TO_DISPLAY_NAME[m1.split('/')[-1]]}: {avg_win_rate:.2%} win rate over {total_matches} matches")
+
     # Plot
     FONT_BOLD.set_size(18)
     _, ax = plt.subplots(figsize=(10, 8))

codeclash/games/__init__.py

@@ -4,7 +4,9 @@
 from codeclash.games.dummy.dummy_game import DummyGame
 from codeclash.games.game import CodeGame
 from codeclash.games.halite.halite import HaliteGame
-from codeclash.games.halite2.halite2 import Halite2Game
+
+# from codeclash.games.halite2.halite2 import Halite2Game # WIP
+# from codeclash.games.halite3.halite3 import Halite3Game # WIP
 from codeclash.games.huskybench.huskybench import HuskyBenchGame
 from codeclash.games.robocode.robocode import RoboCodeGame
 from codeclash.games.robotrumble.robotrumble import RobotRumbleGame
@@ -15,7 +17,6 @@
     CoreWarGame,
     DummyGame,
     HaliteGame,
-    Halite2Game,
     HuskyBenchGame,
     RoboCodeGame,
     RobotRumbleGame,

codeclash/games/halite3/__init__.py

@@ -0,0 +1,8 @@
+from codeclash.games.halite.halite import HaliteGame
+
+
+class Halite3Game(HaliteGame):
+    name: str = "Halite-III"
+    description: str = ""
+    default_args: dict = {}
+    submission: str = "submission"

codeclash/games/halite3/halite3.py

@@ -10,6 +10,12 @@
 from codeclash.constants import RESULT_TIE
 from codeclash.games.game import CodeGame, RoundStats
 
+MAP_EXT_TO_HEADER = {
+    "js": "function robot(state, unit) {",
+    "py": "def robot(state, unit):",
+}
+ROBOTRUMBLE_HIDDEN_EXEC = ".codeclash_exec"
+
 
 class RobotRumbleGame(CodeGame):
     name: str = "RobotRumble"
@@ -51,7 +57,10 @@ def _run_single_simulation(self, agents: list[Player], idx: int, cmd: str):
 
     def execute_round(self, agents: list[Player]):
         self.logger.info(f"Running game with players: {[agent.name for agent in agents]}")
-        args = [f"/{agent.name}/{self.submission}" for agent in agents]
+        args = []
+        for agent in agents:
+            executable = agent.environment.execute(f"cat {ROBOTRUMBLE_HIDDEN_EXEC}")["output"].strip()
+            args.append(f"/{agent.name}/{executable}")
         cmd = f"{self.run_cmd_round} {shlex.join(args)}"
         self.logger.info(f"Running game: {cmd}")
 
@@ -131,21 +140,33 @@ 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]:
-        if self.submission not in agent.environment.execute("ls")["output"]:
-            return False, f"There should be a `{self.submission}` file"
-        if "function robot(state, unit) {" not in agent.environment.execute(f"cat {self.submission}")["output"]:
+        # Determine if robot.js or robot.py exists
+        ext, exists = None, False
+        for possible_ext in MAP_EXT_TO_HEADER.keys():
+            exists_output = agent.environment.execute(f"test -f robot.{possible_ext} && echo 'exists'")["output"]
+            if "exists" == exists_output.strip():
+                ext = possible_ext
+                exists = True
+                break
+        if not exists:
+            return False, "There should be a `robot.js` or `robot.py` file"
+        agent.environment.execute(f'echo "robot.{ext}" > {ROBOTRUMBLE_HIDDEN_EXEC}')
+
+        # Check that the robot function is defined
+        header = MAP_EXT_TO_HEADER[ext]
+        if header not in agent.environment.execute(f"cat robot.{ext}")["output"]:
             return (
                 False,
-                f"{self.submission} does not contain the required robot function. It should be defined as 'function robot(state, unit) {{ ... }}'.",
+                f"robot.{ext} does not contain the required robot function. It should be defined as '{header}'.",
             )
-        test_run_cmd = f"{self.run_cmd_round} {self.submission} {self.submission} -t 1"
+        test_run_cmd = f"{self.run_cmd_round} robot.{ext} robot.{ext} -t 1"
         try:
-            test_run = agent.environment.execute(test_run_cmd, timeout=60)["output"]
+            test_run = agent.environment.execute(test_run_cmd, timeout=10)["output"]
         except subprocess.TimeoutExpired:
             return (
                 False,
-                f"Running {self.submission} (with `{test_run_cmd}`) timed out (60 seconds). Please ensure your code runs efficiently.",
+                f"Running robot.{ext} (with `{test_run_cmd}`) timed out (10 seconds). Please ensure your code runs efficiently.",
             )
         if "Some errors occurred:" in test_run:
-            return False, f"Running {self.submission} (with `{test_run_cmd}`) resulted in errors:\n{test_run}"
+            return False, f"Running robot.{ext} (with `{test_run_cmd}`) resulted in errors:\n{test_run}"
         return True, None

codeclash/games/robotrumble/robotrumble.py

@@ -0,0 +1,21 @@
+tournament:
+  rounds: 3
+game:
+  name: Halite-III
+  sims_per_round: 250
+players:
+- agent: dummy
+  name: p1
+- agent: dummy
+  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.
+
+    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.

configs/test/players/2/halite3.yaml

@@ -0,0 +1,30 @@
+FROM ubuntu:22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install Python 3.10 (and alias python→python3.10), pip, and prerequisites
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends \
+    curl ca-certificates python3.10 python3.10-venv \
+    python3-pip python-is-python3 wget git build-essential jq curl locales cmake \
+ && 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-III.git /workspace \
+    && cd /workspace \
+    && git remote set-url origin https://github.com/emagedoc/Halite-III.git \
+    && unset GITHUB_TOKEN
+
+WORKDIR /workspace
+
+RUN cd game_engine && cmake . && make