AI Game Design Agent Team

system_messages = {
    "story_agent": """
    You are an experienced game story designer specializing in 
    narrative design and world-building. Your task is to:
    
    1. Create a compelling narrative that aligns with the 
       specified game type and target audience.
    2. Design memorable characters with clear motivations 
       and character arcs.
    3. Develop the game's world, including its history, 
       culture, and key locations.
    4. Plan story progression and major plot points.
    5. Integrate the narrative with the specified mood/atmosphere.
    6. Consider how the story supports the core gameplay mechanics.
    """,
    
    "gameplay_agent": """
    You are a senior game mechanics designer with expertise in 
    player engagement and systems design. Your task is to:
    
    1. Design core gameplay loops that match the specified 
       game type and mechanics.
    2. Create progression systems (character development, 
       skills, abilities).
    3. Define player interactions and control schemes for 
       the chosen perspective.
    4. Balance gameplay elements for the target audience.
    5. Design multiplayer interactions if applicable.
    6. Specify game modes and difficulty settings.
    7. Consider the budget and development time constraints.
    """,
    
    "visuals_agent": """
    You are a creative art director with expertise in game 
    visual and audio design. Your task is to:
    
    1. Define the visual style guide matching the specified art style.
    2. Design character and environment aesthetics.
    3. Plan visual effects and animations.
    4. Create the audio direction including music style, 
       sound effects, and ambient sound.
    5. Consider technical constraints of chosen platforms.
    6. Align visual elements with the game's mood/atmosphere.
    7. Work within the specified budget constraints.
    """,
    
    "tech_agent": """
    You are a technical director with extensive game development 
    experience. Your task is to:
    
    1. Recommend appropriate game engine and development tools.
    2. Define technical requirements for all target platforms.
    3. Plan the development pipeline and asset workflow.
    4. Identify potential technical challenges and solutions.
    5. Estimate resource requirements within the budget.
    6. Consider scalability and performance optimization.
    7. Plan for multiplayer infrastructure if applicable.
    """
}

# Functions for agent coordination and context sharing

def update_story_overview(
    story_summary: str, 
    context_variables: dict
) -> SwarmResult:
    """Store story summary and hand off to gameplay agent."""
    context_variables["story"] = story_summary
    st.sidebar.success('Story overview: ' + story_summary)
    return SwarmResult(
        agent="gameplay_agent",
        context_variables=context_variables
    )

def update_gameplay_overview(
    gameplay_summary: str, 
    context_variables: dict
) -> SwarmResult:
    """Store gameplay summary and hand off to visuals agent."""
    context_variables["gameplay"] = gameplay_summary
    st.sidebar.success('Gameplay overview: ' + gameplay_summary)
    return SwarmResult(
        agent="visuals_agent",
        context_variables=context_variables
    )

def update_visuals_overview(
    visuals_summary: str, 
    context_variables: dict
) -> SwarmResult:
    """Store visuals summary and hand off to tech agent."""
    context_variables["visuals"] = visuals_summary
    st.sidebar.success('Visuals overview: ' + visuals_summary)
    return SwarmResult(
        agent="tech_agent",
        context_variables=context_variables
    )

def update_tech_overview(
    tech_summary: str, 
    context_variables: dict
) -> SwarmResult:
    """Store tech summary and hand off back to story agent."""
    context_variables["tech"] = tech_summary
    st.sidebar.success('Tech overview: ' + tech_summary)
    return SwarmResult(
        agent="story_agent",
        context_variables=context_variables
    )

# Execute swarm chat
result, _, _ = initiate_swarm_chat(
    initial_agent=story_agent,
    agents=[story_agent, gameplay_agent, visuals_agent, tech_agent],
    user_agent=None,
    messages=task,
    max_rounds=13,  # 2 phases per agent + 1 initial
)

# Extract individual outputs
output = {
    'story': result.chat_history[-4]['content'],
    'gameplay': result.chat_history[-3]['content'],
    'visuals': result.chat_history[-2]['content'],
    'tech': result.chat_history[-1]['content']
}

# Display in expandable sections
with st.expander("Story Design"):
    st.markdown(output['story'])

with st.expander("Gameplay Mechanics"):
    st.markdown(output['gameplay'])

with st.expander("Visual and Audio Design"):
    st.markdown(output['visuals'])

with st.expander("Technical Recommendations"):
    st.markdown(output['tech'])

import streamlit as st

st.title("🎮 AI Game Design Agent Team")

st.info("""
**Meet Your AI Game Design Team:**

🎭 **Story Agent** - Crafts compelling narratives
🎮 **Gameplay Agent** - Creates engaging mechanics
🎨 **Visuals Agent** - Shapes artistic vision
⚙️ **Tech Agent** - Provides technical direction
""")

# User inputs
st.subheader("Game Details")
col1, col2 = st.columns(2)

with col1:
    background_vibe = st.text_input(
        "Background Vibe",
        "Epic fantasy with dragons"
    )
    game_type = st.selectbox(
        "Game Type",
        ["RPG", "Action", "Adventure", "Puzzle", 
         "Strategy", "Simulation", "Platform", "Horror"]
    )
    target_audience = st.selectbox(
        "Target Audience",
        ["Kids (7-12)", "Teens (13-17)", 
         "Young Adults (18-25)", "Adults (26+)", "All Ages"]
    )

with col2:
    art_style = st.selectbox(
        "Art Style",
        ["Realistic", "Cartoon", "Pixel Art", "Stylized",
         "Low Poly", "Anime", "Hand-drawn"]
    )
    platform = st.multiselect(
        "Target Platforms",
        ["PC", "Mobile", "PlayStation", "Xbox",
         "Nintendo Switch", "Web Browser"]
    )
    development_time = st.slider(
        "Development Time (months)",
        1, 36, 12
    )

if st.button("Generate Game Concept"):
    # Run swarm chat and display results
    pass

# Art and presentation
art_style = "Stylized"  # Realistic, Cartoon, Pixel Art, etc.
mood = ["Epic", "Mysterious", "Tense"]

# Platform affects visual fidelity
platform = ["PC", "PlayStation", "Xbox"]

# Core mechanics and features
core_mechanics = [
    "Combat",
    "Exploration",
    "Resource Management",
    "Crafting"
]

# Additional features
unique_features = "Dragon bonding system"

# Constraints and requirements
development_time = 12  # months
budget = 10000  # USD

# Level of detail in response
depth = "High"  # Low, Medium, High

# Inspiration
inspiration = "Skyrim, Dragon Age, The Witcher"

# Sequential, manual coordination
story = story_agent.run(task)
gameplay = gameplay_agent.run(task + story)
visuals = visuals_agent.run(task + story + gameplay)
tech = tech_agent.run(task + story + gameplay + visuals)

# Automatic coordination, context sharing
result = initiate_swarm_chat(
    initial_agent=story_agent,
    agents=[story_agent, gameplay_agent, 
            visuals_agent, tech_agent],
    messages=task,
    max_rounds=13
)