Init Halite arena

Author: john-b-yang

codeclash/games/__init__.py

@@ -3,6 +3,7 @@
 from codeclash.games.corewar.corewar import CoreWarGame
 from codeclash.games.dummy.dummy_game import DummyGame
 from codeclash.games.game import CodeGame
+from codeclash.games.halite.halite import HaliteGame
 from codeclash.games.huskybench.huskybench import HuskyBenchGame
 from codeclash.games.robocode.robocode import RoboCodeGame
 from codeclash.games.robotrumble.robotrumble import RobotRumbleGame
@@ -12,6 +13,7 @@
     BattleSnakeGame,
     CoreWarGame,
     DummyGame,
+    HaliteGame,
     HuskyBenchGame,
     RoboCodeGame,
     RobotRumbleGame,

codeclash/games/halite/__init__.py

@@ -0,0 +1,91 @@
+import re
+import shlex
+import subprocess
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from tqdm.auto import tqdm
+
+from codeclash.agents.player import Player
+from codeclash.constants import RESULT_TIE
+from codeclash.games.game import CodeGame, RoundStats
+
+HALITE_LOG = "sim_{idx}.log"
+
+
+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"""
+    default_args: dict = {}
+
+    def __init__(self, config, **kwargs):
+        super().__init__(config, **kwargs)
+        self.run_cmd_round: str = f"./environment/halite --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:
+            entries.append(f"python /{agent.name}/airesources/Python/RandomBot.py")
+        cmd = f"{self.run_cmd_round} {shlex.join(entries)}"
+        self.logger.info(f"Running game: {cmd}")
+        with ThreadPoolExecutor(5) 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()
+
+    def get_results(self, agents: list[Player], round_num: int, stats: RoundStats):
+        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 :]
+                for line in lines:
+                    match = re.search(pattern, line)
+                    if match:
+                        player_idx = int(match.group(1)) - 1
+                        rank = int(match.group(3))
+                        if rank == 1:
+                            winners.append(agents[player_idx].name)
+
+        # Count wins
+        win_counts = Counter(winners)
+
+        # Find all winners with the maximum count
+        max_wins = max(win_counts.values(), default=0)
+        overall_winners = [name for name, count in win_counts.items() if count == max_wins]
+
+        # Update stats
+        stats.winner = RESULT_TIE if len(overall_winners) > 1 else overall_winners[0]
+        stats.scores = dict(win_counts)
+        for player, score in win_counts.items():
+            if player != RESULT_TIE:
+                stats.player_stats[player].score = score
+
+    def validate_code(self, agent: Player) -> tuple[bool, str | None]:
+        return True, None

codeclash/games/halite/halite.py

@@ -33,7 +33,7 @@ def __init__(self, config, **kwargs):
             else:
                 self.run_cmd_round += f" --{arg} {val}"
 
-    def _run_single_simulation(self, agents: list[Player], idx: int, cmd: str) -> str:
+    def _run_single_simulation(self, agents: list[Player], idx: int, cmd: str):
         """Run a single robotrumble simulation and return the output."""
         cmd = f"{cmd} > {self.log_env / f'sim_{idx}.{self.sim_ext}'}"
 
@@ -42,17 +42,17 @@ def _run_single_simulation(self, agents: list[Player], idx: int, cmd: str) -> st
             response = self.environment.execute(cmd, timeout=120)
         except subprocess.TimeoutExpired:
             self.logger.warning(f"RobotRumble simulation {idx} timed out: {cmd}")
-            return ""
+            return
         if response["returncode"] != 0:
             self.logger.warning(
                 f"RobotRumble simulation {idx} failed with exit code {response['returncode']}:\n{response['output']}"
             )
-        return response["output"]
 
     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]
         cmd = f"{self.run_cmd_round} {shlex.join(args)}"
+        self.logger.info(f"Running game: {cmd}")
 
         with ThreadPoolExecutor(5) as executor:
             # Submit all simulations to the thread pool
@@ -61,9 +61,6 @@ def execute_round(self, agents: list[Player]):
                 for idx in range(self.game_config.get("sims_per_round", 100))
             ]
 
-            # Log command being run
-            self.logger.info(f"Running game: {cmd}")
-
             # Collect results as they complete
             for future in tqdm(as_completed(futures), total=len(futures)):
                 future.result()
@@ -117,21 +114,18 @@ def get_results(self, agents: list[Player], round_num: int, stats: RoundStats):
                 else self._get_winner_json(output_file, agents)
             )
 
-        # Count occurrences of each winner
-        counts = Counter(winners)
+        # Count wins
+        win_counts = Counter(winners)
 
         # Find all winners with the maximum count
-        max_count = max(counts.values())
-        top_winners = [w for w, c in counts.items() if c == max_count]
-
-        # If multiple winners have the same count, return RESULT_TIE
-        final_winner = RESULT_TIE if len(top_winners) > 1 else top_winners[0]
+        max_wins = max(win_counts.values())
+        overall_winners = [name for name, count in win_counts.items() if count == max_wins]
 
         # Update stats
-        stats.winner = final_winner
+        stats.winner = RESULT_TIE if len(overall_winners) > 1 else overall_winners[0]
         stats.details.append(f"In this round, {agents[0].name} was Blue and {agents[1].name} was Red.")
-        stats.scores = dict(counts)
-        for player, score in counts.items():
+        stats.scores = dict(win_counts)
+        for player, score in win_counts.items():
             if player != RESULT_TIE:
                 stats.player_stats[player].score = score
 

codeclash/games/robotrumble/robotrumble.py

@@ -0,0 +1,21 @@
+tournament:
+  rounds: 1
+game:
+  name: Halite
+  sims_per_round: 10
+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/halite.yaml

@@ -0,0 +1,20 @@
+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 \
+ && rm -rf /var/lib/apt/lists/*
+
+ARG GITHUB_TOKEN
+RUN git clone https://${GITHUB_TOKEN}@github.com/emagedoc/Halite.git /workspace \
+    && cd /workspace \
+    && git remote set-url origin https://github.com/emagedoc/Halite.git \
+    && unset GITHUB_TOKEN
+
+WORKDIR /workspace
+
+RUN cd environment && make