Add Halite configs v0

Author: john-b-yang

codeclash/games/halite/halite.py

@@ -12,7 +12,6 @@
 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
@@ -36,20 +35,21 @@
 
 class HaliteGame(CodeGame):
     name: str = "Halite"
-    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.
+    description: str = """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.
+Your submission should be stored in the `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 = {}
+    submission: str = "submission"
 
     def __init__(self, config, **kwargs):
         super().__init__(config, **kwargs)
@@ -123,7 +123,7 @@ def get_results(self, agents: list[Player], round_num: int, stats: RoundStats):
     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
+        sub_path = Path(agent.environment.config.cwd) / self.submission
         ls_output = agent.environment.execute("ls", cwd=sub_path)["output"]
         main_files = [
             fname
@@ -144,15 +144,15 @@ def validate_code(self, agent: Player) -> tuple[bool, str | None]:
             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"
+                return False, f"Compilation failed (ran {compile_cmd} inside {self.submission}): timed out"
             if compile_response["returncode"] != 0:
                 return (
                     False,
-                    f"Compilation failed (ran {compile_cmd} inside {HALITE_SUBMISSION}): {compile_response['output']}",
+                    f"Compilation failed (ran {compile_cmd} inside {self.submission}): {compile_response['output']}",
                 )
 
         # Check that submission runs in competition
-        executable = MAP_FILE_TYPE_TO_RUN[main_ext].format(path=HALITE_SUBMISSION, name="main")
+        executable = MAP_FILE_TYPE_TO_RUN[main_ext].format(path=self.submission, name="main")
         run_cmd = f"./environment/halite {shlex.join([executable, executable])}"
         try:
             run_response = agent.environment.execute(run_cmd, timeout=15)
@@ -162,6 +162,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}/{HALITE_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

configs/main/Halite__claude-sonnet-4-20250514__claude-sonnet-4-5-20250929__r15__s250.yaml

@@ -0,0 +1,50 @@
+tournament:
+  rounds: 15
+game:
+  name: Halite
+  sims_per_round: 250
+  args: {}
+players:
+- agent: mini
+  name: claude-sonnet-4-20250514
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@anthropic/claude-sonnet-4-20250514'
+      model_class: portkey
+      model_kwargs:
+        temperature: 0.2
+        max_tokens: 4096
+- agent: mini
+  name: claude-sonnet-4-5-20250929
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@anthropic/claude-sonnet-4-5-20250929'
+      model_class: portkey
+      model_kwargs:
+        temperature: 0.2
+        max_tokens: 4096
+prompts:
+  game_description: |-
+    You are a software developer ({{player_id}}) competing in a coding game called Halite.
+    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 `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.
+
+
+    The game is played in 15 rounds. For every round, you (and your competitors) 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 in `submission`, located in {{working_dir}}.
+    {{working_dir}} is your codebase, which contains both your both and supporting assets.
+    All of your commands will be executed in the {{working_dir}} directory (see notes below).

configs/main/Halite__claude-sonnet-4-20250514__gemini-2.5-pro__r15__s250.yaml

@@ -0,0 +1,49 @@
+tournament:
+  rounds: 15
+game:
+  name: Halite
+  sims_per_round: 250
+  args: {}
+players:
+- agent: mini
+  name: claude-sonnet-4-20250514
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@anthropic/claude-sonnet-4-20250514'
+      model_class: portkey
+      model_kwargs:
+        temperature: 0.2
+        max_tokens: 4096
+- agent: mini
+  name: gemini-2.5-pro
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@google/gemini-2.5-pro'
+      model_class: portkey
+      model_kwargs:
+        temperature: 0.2
+prompts:
+  game_description: |-
+    You are a software developer ({{player_id}}) competing in a coding game called Halite.
+    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 `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.
+
+
+    The game is played in 15 rounds. For every round, you (and your competitors) 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 in `submission`, located in {{working_dir}}.
+    {{working_dir}} is your codebase, which contains both your both and supporting assets.
+    All of your commands will be executed in the {{working_dir}} directory (see notes below).

configs/main/Halite__claude-sonnet-4-20250514__glm-4-5__r15__s250.yaml

@@ -0,0 +1,48 @@
+tournament:
+  rounds: 15
+game:
+  name: Halite
+  sims_per_round: 250
+  args: {}
+players:
+- agent: mini
+  name: claude-sonnet-4-20250514
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@anthropic/claude-sonnet-4-20250514'
+      model_class: portkey
+      model_kwargs:
+        temperature: 0.2
+        max_tokens: 4096
+- agent: mini
+  name: glm-4-5
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@fireworks/accounts/fireworks/models/glm-4-5'
+      model_class: portkey
+      litellm_model_name_override: deepinfra/zai-org/GLM-4.5
+prompts:
+  game_description: |-
+    You are a software developer ({{player_id}}) competing in a coding game called Halite.
+    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 `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.
+
+
+    The game is played in 15 rounds. For every round, you (and your competitors) 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 in `submission`, located in {{working_dir}}.
+    {{working_dir}} is your codebase, which contains both your both and supporting assets.
+    All of your commands will be executed in the {{working_dir}} directory (see notes below).

configs/main/Halite__claude-sonnet-4-20250514__gpt-5-mini__r15__s250.yaml

@@ -0,0 +1,47 @@
+tournament:
+  rounds: 15
+game:
+  name: Halite
+  sims_per_round: 250
+  args: {}
+players:
+- agent: mini
+  name: claude-sonnet-4-20250514
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@anthropic/claude-sonnet-4-20250514'
+      model_class: portkey
+      model_kwargs:
+        temperature: 0.2
+        max_tokens: 4096
+- agent: mini
+  name: gpt-5-mini
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@openai/gpt-5-mini'
+      model_class: portkey
+prompts:
+  game_description: |-
+    You are a software developer ({{player_id}}) competing in a coding game called Halite.
+    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 `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.
+
+
+    The game is played in 15 rounds. For every round, you (and your competitors) 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 in `submission`, located in {{working_dir}}.
+    {{working_dir}} is your codebase, which contains both your both and supporting assets.
+    All of your commands will be executed in the {{working_dir}} directory (see notes below).

configs/main/Halite__claude-sonnet-4-20250514__gpt-5__r15__s250.yaml

@@ -0,0 +1,47 @@
+tournament:
+  rounds: 15
+game:
+  name: Halite
+  sims_per_round: 250
+  args: {}
+players:
+- agent: mini
+  name: claude-sonnet-4-20250514
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@anthropic/claude-sonnet-4-20250514'
+      model_class: portkey
+      model_kwargs:
+        temperature: 0.2
+        max_tokens: 4096
+- agent: mini
+  name: gpt-5
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@openai/gpt-5'
+      model_class: portkey
+prompts:
+  game_description: |-
+    You are a software developer ({{player_id}}) competing in a coding game called Halite.
+    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 `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.
+
+
+    The game is played in 15 rounds. For every round, you (and your competitors) 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 in `submission`, located in {{working_dir}}.
+    {{working_dir}} is your codebase, which contains both your both and supporting assets.
+    All of your commands will be executed in the {{working_dir}} directory (see notes below).

configs/main/Halite__claude-sonnet-4-20250514__grok-code-fast-1__r15__s250.yaml

@@ -0,0 +1,50 @@
+tournament:
+  rounds: 15
+game:
+  name: Halite
+  sims_per_round: 250
+  args: {}
+players:
+- agent: mini
+  name: claude-sonnet-4-20250514
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@anthropic/claude-sonnet-4-20250514'
+      model_class: portkey
+      model_kwargs:
+        temperature: 0.2
+        max_tokens: 4096
+- agent: mini
+  name: grok-code-fast-1
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: '@x-ai/grok-code-fast-1'
+      model_class: portkey
+      litellm_model_name_override: xai/grok-code-fast-1
+      model_kwargs:
+        temperature: 0.2
+prompts:
+  game_description: |-
+    You are a software developer ({{player_id}}) competing in a coding game called Halite.
+    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 `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.
+
+
+    The game is played in 15 rounds. For every round, you (and your competitors) 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 in `submission`, located in {{working_dir}}.
+    {{working_dir}} is your codebase, which contains both your both and supporting assets.
+    All of your commands will be executed in the {{working_dir}} directory (see notes below).