Custom Board Variants

from dataclasses import dataclass
from typing import Optional

@dataclass
class GameConfig:
    """Game configuration constants."""
    
    # Board configuration
    BOARD_SIZE: int = 25  # Total number of words on the board
    BLUE_WORDS: int = 9   # Blue team words (starting team)
    RED_WORDS: int = 8    # Red team words
    NEUTRAL_WORDS: int = 7  # Neutral words
    BOMB_COUNT: int = 1   # Number of bomb/assassin words
    
    # Game rules
    MAX_TURNS: int = 50   # Maximum turns before game ends
    MAX_GUESSES_PER_TURN: Optional[int] = None  # None = hint_count + 1
    STARTING_TEAM: str = "BLUE"  # Which team starts (BLUE or RED)
    
    # Validation
    MIN_HINT_COUNT: int = 1
    MAX_HINT_COUNT: int = 9

@classmethod
def custom(cls, board_size: int = 25, starting_team: str = "BLUE") -> "GameConfig":
    """Create a custom game configuration with proportional word distributions."""
    if board_size < 9:
        raise ValueError("Board size must be at least 9")
    if board_size % 2 == 0:
        raise ValueError("Board size should be odd for fair play")
    
    # Calculate proportional distribution
    starting_words = (board_size - 1) // 3 + 1
    other_words = starting_words - 1
    neutral_words = board_size - starting_words - other_words - 1
    
    return cls(
        BOARD_SIZE=board_size,
        BLUE_WORDS=starting_words if starting_team == "BLUE" else other_words,
        RED_WORDS=starting_words if starting_team == "RED" else other_words,
        NEUTRAL_WORDS=neutral_words,
        BOMB_COUNT=1,
        MAX_TURNS=max(50, board_size * 2),
        STARTING_TEAM=starting_team
    )

from orchestrator import Orchestrator
from config import GameConfig
from game import Team
from agents.llm.baml_agents import BAMLHintGiver, BAMLGuesser, BAMLModel

# Create custom config
custom_config = GameConfig(
    BOARD_SIZE=15,
    BLUE_WORDS=6,
    RED_WORDS=5,
    NEUTRAL_WORDS=3,
    BOMB_COUNT=1,
    MAX_TURNS=30,
    STARTING_TEAM="BLUE"
)

# Initialize orchestrator with custom config
orchestrator = Orchestrator(
    verbose=True,
    config=custom_config
)

# Create agents
blue_hg = BAMLHintGiver(Team.BLUE, BAMLModel.GPT4O_MINI)
blue_g = BAMLGuesser(Team.BLUE, BAMLModel.GPT4O_MINI)
red_hg = BAMLHintGiver(Team.RED, BAMLModel.CLAUDE_SONNET_45)
red_g = BAMLGuesser(Team.RED, BAMLModel.CLAUDE_SONNET_45)

# Play game with custom board
result = orchestrator.play_game(
    blue_hint_giver=blue_hg,
    blue_guesser=blue_g,
    red_hint_giver=red_hg,
    red_guesser=red_g
)

print(f"Winner: {result.winner}")
print(f"Turns: {result.total_turns}")

class Config:
    """Main configuration class combining all config sections."""
    
    def __init__(self):
        self.game = GameConfig()
        self.llm = LLMConfig()
        self.orchestrator = OrchestratorConfig()
        self.data = DataConfig()
    
    @classmethod
    def custom_game(cls, board_size: int = 25, **kwargs) -> "Config":
        """Create config with custom game settings."""
        config = cls()
        config.game = GameConfig.custom(board_size, **kwargs)
        return config

def validate(self) -> bool:
    """Validate that the configuration is internally consistent."""
    # Board size must be at least 9
    if self.BOARD_SIZE < 9:
        raise ValueError("Board size must be at least 9")
    
    # Board size should be odd for fair play
    if self.BOARD_SIZE % 2 == 0:
        raise ValueError("Board size should be odd for fair play")
    
    # Word counts must sum to board size
    total = self.BLUE_WORDS + self.RED_WORDS + self.NEUTRAL_WORDS + self.BOMB_COUNT
    if total != self.BOARD_SIZE:
        raise ValueError(
            f"Word counts don't add up to board size: "
            f"{self.BLUE_WORDS} + {self.RED_WORDS} + {self.NEUTRAL_WORDS} + {self.BOMB_COUNT} = {total}, "
            f"expected {self.BOARD_SIZE}"
        )
    
    return True

from orchestrator import Orchestrator
from config import GameConfig
from game import Team
from agents.llm.baml_agents import BAMLHintGiver, BAMLGuesser, BAMLModel

# Define variants
variants = [
    ("Small", GameConfig.custom(9)),
    ("Standard", GameConfig.custom(25)),
    ("Large", GameConfig.custom(49)),
]

# Test model on each variant
model = BAMLModel.GPT4O_MINI
results = {}

for variant_name, config in variants:
    orchestrator = Orchestrator(config=config)
    
    # Run 10 games per variant
    wins = 0
    for _ in range(10):
        result = orchestrator.play_game(
            blue_hint_giver=BAMLHintGiver(Team.BLUE, model),
            blue_guesser=BAMLGuesser(Team.BLUE, model),
            red_hint_giver=BAMLHintGiver(Team.RED, BAMLModel.CLAUDE_SONNET_45),
            red_guesser=BAMLGuesser(Team.RED, BAMLModel.CLAUDE_SONNET_45)
        )
        if result.winner == "blue":
            wins += 1
    
    results[variant_name] = wins / 10
    print(f"{variant_name}: {results[variant_name]:.1%} win rate")