Add script to generate configs

Author: john-b-yang

codeclash/games/battlecode/battlecode.py

@@ -11,12 +11,18 @@
 
 class BattleCodeGame(CodeGame):
     name: str = "BattleCode"
+    description: str = """Battlecode 25 throws you into a real-time strategy showdown where your Python bot pilots a team of specialized robots—Soldiers, Moppers, Splashers—alongside towers that spawn units or generate resources.
+Your mission: paint over 70% of the map (or eliminate the enemy) by coordinating cleanups, area cover, and tower-building through tight bytecode budgets and clever unit synergy."""
+    default_args: dict = {
+        "maps": "quack",
+    }
+    submission: str = "src/mysubmission"
 
     def __init__(self, config, **kwargs):
         super().__init__(config, **kwargs)
         assert len(config["players"]) == 2, "BattleCode is a two-player game"
         self.run_cmd_round: str = "python run.py run"
-        for arg, val in self.game_config.get("args", {}).items():
+        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}"

codeclash/games/battlesnake/battlesnake.py

@@ -13,11 +13,19 @@
 
 class BattleSnakeGame(CodeGame):
     name: str = "BattleSnake"
+    submission: str = "main.py"
+    description: str = """Your bot (`main.py`) controls a snake on a grid-based board.
+Snakes collect food, avoid collisions, and try to outlast their opponents."""
+    default_args: dict = {
+        "width": 11,
+        "height": 11,
+        "browser": False,
+    }
 
     def __init__(self, config, **kwargs):
         super().__init__(config, **kwargs)
         self.run_cmd_round: str = "./battlesnake play"
-        for arg, val in self.game_config.get("args", {}).items():
+        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}"
@@ -85,7 +93,7 @@ def execute_round(self, agents: list[Player]):
             player2port[agent.name] = port
             # Surprisingly slow despite using &
             # Start server in background - just add & to run in background!
-            self.environment.execute(f"PORT={port} python main.py &", cwd=f"/{agent.name}")
+            self.environment.execute(f"PORT={port} python {self.submission} &", cwd=f"/{agent.name}")
 
         self.logger.debug(f"Waiting for ports: {player2port}")
         available_ports = self._wait_for_ports(list(player2port.values()))
@@ -121,7 +129,7 @@ def execute_round(self, agents: list[Player]):
                     future.result()
         finally:
             # Kill all python servers when done
-            self.environment.execute("pkill -f 'python main.py' || true")
+            self.environment.execute(f"pkill -f 'python {self.submission}' || true")
 
     def get_results(self, agents: list[Player], round_num: int, stats: RoundStats):
         scores = {}
@@ -154,10 +162,10 @@ 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 "main.py" not in agent.environment.execute("ls")["output"]:
-            return False, "No main.py file found in the root directory"
+        if self.submission not in agent.environment.execute("ls")["output"]:
+            return False, f"No {self.submission} file found in the root directory"
         # note: no longer calling splitlines
-        bot_content = agent.environment.execute("cat main.py")["output"]
+        bot_content = agent.environment.execute(f"cat {self.submission}")["output"]
         error_msg = []
         for func in [
             "def info(",
@@ -166,7 +174,7 @@ def validate_code(self, agent: Player) -> tuple[bool, str | None]:
             "def move(",
         ]:
             if func not in bot_content:
-                error_msg.append(f"There should be a `{func}` function implemented in `main.py`")
+                error_msg.append(f"There should be a `{func}` function implemented in `{self.submission}`")
         if len(error_msg) > 0:
             return False, "\n".join(error_msg + ["Don't change the function signatures!"])
         return True, None

codeclash/games/corewar/corewar.py

@@ -10,11 +10,14 @@
 
 class CoreWarGame(CodeGame):
     name: str = "CoreWar"
+    description: str = """CoreWar is a programming battle where you write "warriors" in an assembly-like language called Redcode to compete within a virtual machine (MARS), aiming to eliminate your rivals by making their code self-terminate.
+Victory comes from crafting clever tactics—replicators, scanners, bombers—that exploit memory layout and instruction timing to control the core."""
+    submission: str = f"warriors/{COREWAR_FILE}"
 
     def __init__(self, config, **kwargs):
         super().__init__(config, **kwargs)
         self.run_cmd_round: str = "./src/pmars"
-        for arg, val in self.game_config.get("args", {}).items():
+        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}"

codeclash/games/dummy/dummy_game.py

@@ -9,9 +9,11 @@
 
 class DummyGame(CodeGame):
     name: str = "DummyGame"
+    description: str = """WARNING: This is a dummy game meant for testing the CodeClash infrastructure. It does not represent a real game."""
+    submission: str = "main.py"
 
     def execute_round(self, agents: list[Player]) -> None:
-        args = [f"/{agent.name}/main.py" for agent in agents]
+        args = [f"/{agent.name}/{self.submission}" for agent in agents]
         cmd = f"python engine.py {' '.join(args)} -r {self.game_config['sims_per_round']} > {self.log_env / DUMMY_LOG};"
         self.logger.info(f"Running game: {cmd}")
         assert_zero_exit_code(self.environment.execute(cmd))

codeclash/games/game.py

@@ -60,6 +60,9 @@ def to_dict(self) -> dict[str, Any]:
 
 class CodeGame(ABC):
     name: str
+    description: str
+    default_args: dict = {}
+    submission: str
 
     def __init__(self, config: dict, *, tournament_id: str, local_output_dir: Path, keep_containers: bool = False):
         """The CodeGame class is responsible for running games, i.e., taking a list of code

codeclash/games/huskybench/huskybench.py

@@ -12,6 +12,9 @@
 
 class HuskyBenchGame(CodeGame):
     name: str = "HuskyBench"
+    description: str = """In this game, you will write code to control a poker-playing bot, aiming to outsmart your opponents and win chips.
+Victory comes from crafting clever strategies—bluffing, reading opponents, and managing your chip stack effectively."""
+    submission: str = "client/player.py"
 
     def __init__(self, config, **kwargs):
         super().__init__(config, **kwargs)
@@ -20,7 +23,7 @@ def __init__(self, config, **kwargs):
             f"python engine/main.py --port {HB_PORT} --players {self.num_players} "
             f"--sim --sim-rounds {self.game_config['sims_per_round']}"
         )
-        for arg, val in self.game_config.get("args", {}).items():
+        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}"

codeclash/games/robocode/robocode.py

@@ -12,11 +12,18 @@
 
 class RoboCodeGame(CodeGame):
     name: str = "RoboCode"
+    description: str = """Robocode (Tank Royale) is a programming game where your code is the tank: each turn your bot sends intents—speed plus body/gun/radar turn rates and firepower—based on the game state it perceives via radar.
+Your program decides how to move, aim, and fire in a deterministic, turn-based arena to outlast other bots."""
+    default_args: dict = {
+        "nodisplay": True,
+        "nosound": True,
+    }
+    submission: str = "robots/custom/"
 
     def __init__(self, config, **kwargs):
         super().__init__(config, **kwargs)
         self.run_cmd_round: str = "./robocode.sh"
-        for arg, val in self.game_config.get("args", {}).items():
+        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}"

codeclash/games/robotrumble/robotrumble.py

@@ -12,6 +12,9 @@
 
 class RobotRumbleGame(CodeGame):
     name: str = "RobotRumble"
+    description: str = """RobotRumble is a turn-based coding battle where you program a team of robots in Python to move, attack, and outmaneuver your opponent on a grid.
+Every decision is driven by your code, and victory comes from crafting logic that positions robots smartly, times attacks well, and adapts over the 100-turn match."""
+    submission: str = "robot.py"
 
     def __init__(self, config, **kwargs):
         super().__init__(config, **kwargs)
@@ -20,7 +23,7 @@ def __init__(self, config, **kwargs):
 
     def _run_single_simulation(self, agents: list[Player], idx: int) -> str:
         """Run a single robotrumble simulation and return the output."""
-        args = [f"/{agent.name}/robot.py" for agent in agents]
+        args = [f"/{agent.name}/{self.submission}" for agent in agents]
         cmd = f"{self.run_cmd_round} {shlex.join(args)} > {self.log_env / f'sim_{idx}.txt'}"
 
         # https://github.com/emagedoc/CodeClash/issues/62 (timeouts)
@@ -92,15 +95,15 @@ 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 "robot.py" not in agent.environment.execute("ls")["output"]:
-            return False, "There should be a `robot.py` file"
-        if "def robot(state, unit):" not in agent.environment.execute("cat robot.py")["output"]:
+        if self.submission not in agent.environment.execute("ls")["output"]:
+            return False, f"There should be a `{self.submission}` file"
+        if "def robot(state, unit):" not in agent.environment.execute(f"cat {self.submission}")["output"]:
             return (
                 False,
-                "robot.py does not contain the required robot function. It should be defined as 'def robot(state, unit): ...'",
+                f"{self.submission} does not contain the required robot function. It should be defined as 'def robot(state, unit): ...'",
             )
-        test_run_cmd = f"{self.run_cmd_round} robot.py robot.py -t 1"
+        test_run_cmd = f"{self.run_cmd_round} {self.submission} {self.submission} -t 1"
         test_run = agent.environment.execute(test_run_cmd)["output"]
         if "Some errors occurred:" in test_run:
-            return False, f"Running robot.py (with `{test_run_cmd}`) resulted in errors:\n{test_run}"
+            return False, f"Running {self.submission} (with `{test_run_cmd}`) resulted in errors:\n{test_run}"
         return True, None

configs/generate_confs.py

@@ -0,0 +1,121 @@
+import argparse
+from pathlib import Path
+
+import yaml
+
+from codeclash.games import (
+    BattleCodeGame,
+    BattleSnakeGame,
+    CodeGame,
+    CoreWarGame,
+    HuskyBenchGame,
+    RoboCodeGame,
+    RobotRumbleGame,
+)
+
+
+class IncludeTag:
+    def __init__(self, value):
+        self.value = value
+
+
+def include_representer(dumper, data):
+    return dumper.represent_scalar("!include", data.value)
+
+
+yaml.add_representer(IncludeTag, include_representer)
+
+ARENAS: list[CodeGame] = [
+    BattleCodeGame,
+    BattleSnakeGame,
+    CoreWarGame,
+    HuskyBenchGame,
+    RoboCodeGame,
+    RobotRumbleGame,
+]
+
+
+def prompt_game_desc(arena, rounds):
+    return f"""You are a software developer ({{{{player_id}}}}) competing in a coding game called {arena.name}.
+{arena.description}
+
+The game is played in {rounds} 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 `{arena.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).
+"""
+
+
+def get_name(p):
+    return p["model_name"].split("/")[-1]
+
+
+def main(models, rounds, simulations, output):
+    # Get all unique pairs of models
+    models = yaml.safe_load(open(models))
+    Path(output).mkdir(parents=True, exist_ok=True)
+    pairs = []
+    for i in range(len(models)):
+        for j in range(i + 1, len(models)):
+            pairs.append((models[i], models[j]))
+
+    for arena in ARENAS:
+        for pair in pairs:
+            config = {
+                "tournament": {
+                    "rounds": rounds,
+                },
+                "game": {
+                    "name": arena.name,
+                    "sims_per_round": simulations,
+                    "args": arena.default_args,
+                },
+                "players": [
+                    {
+                        "agent": "mini",
+                        "name": get_name(p),
+                        "config": {"agent": IncludeTag("mini/default.yaml"), "model": p},
+                    }
+                    for p in pair
+                ],
+                "prompts": {"game_description": prompt_game_desc(arena, rounds)},
+            }
+            config_name = f"{arena.name}__{get_name(pair[0])}__{get_name(pair[1])}__r{rounds}__s{simulations}.yaml"
+            with open(f"{output}/{config_name}", "w") as f:
+                yaml.dump(config, f, default_style=None, sort_keys=False)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Generate configuration files.")
+    parser.add_argument(
+        "-m",
+        "--models",
+        type=str,
+        default="configs/model_configs.yaml",
+        help="Path to model configurations.",
+    )
+    parser.add_argument(
+        "-r",
+        "--rounds",
+        type=int,
+        default=15,
+        help="Number of rounds per tournament for the configuration (default: 15).",
+    )
+    parser.add_argument(
+        "-s",
+        "--simulations",
+        type=int,
+        default=1000,
+        help="Number of simulations to run per round (default: 1000).",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        default="configs/main/",
+        help="Output directory for configuration files (default: main/).",
+    )
+    args = parser.parse_args()
+    main(**vars(args))

configs/model_configs.yaml

@@ -0,0 +1,21 @@
+- model_name: "anthropic/claude-opus-4-1-20250805"
+  model_kwargs:
+    temperature: 0.0
+- model_name: "anthropic/claude-sonnet-4-20250514"
+  model_kwargs:
+    temperature: 0.0
+- model_name: "@x-ai/grok-code-fast-1"
+  model_class: portkey
+  litellm_model_name_override: "xai/grok-code-fast-1"
+- model_name: "@google/gemini-2.5-pro"
+  model_class: portkey
+- model_name: "@zhipu/glm-4.5"
+  model_class: portkey
+- model_name: "@openai/gpt-5"
+  model_class: portkey
+- model_name: "@openai/gpt-5-mini"
+  model_class: portkey
+- model_name: "@qwen/qwen-3-coder"
+  model_class: portkey
+- model_name: "@openai/o3"
+  model_class: portkey