A new start

.env.example

@@ -0,0 +1 @@
+GEMINI_API_KEY=KEY

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,178 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+versions/
+
+.gradio
+generated/

README.md

@@ -0,0 +1,57 @@
+---
+title: Test
+emoji: 🎮
+colorFrom: yellow
+colorTo: green
+sdk: gradio
+sdk_version: 5.32.0
+app_file: src/main.py
+pinned: false
+license: mit
+---
+
+# 🎮 LLMGameHub | gradio-mcp-hackaton
+
+**LLMGameHub** is a next-generation playground where anyone can create, share, and play AI-powered games based on their own stories and texts.
+
+
+https://github.com/user-attachments/assets/1ec276e2-ba95-4e85-b5b9-e8831703a52c
+
+
+## What is LLMGameHub?
+
+LLMGameHub is an interactive platform that brings together the power of large language models and generative AI to let users co-create narrative games, visual novels, and interactive experiences in just a few clicks.  
+Whether you're a writer, gamer, or simply curious, you can turn your ideas into playable games — no coding required!
+
+## Key Features
+
+- **User-driven Storytelling:**  
+  Players build their own visual novel game by selecting key elements: setting, main character, and genre (e.g., horror, detective, romance, adventure).
+- **Auto-generated Content:**  
+  The platform dynamically generates engaging narratives, character descriptions, dialogue, and visual assets (images and short videos) tailored to the user's preferences.
+- **Multi-Agent LLM System:**  
+  Behind every game is a team of collaborating AI agents — each with their own roles — to create rich, believable, and creative worlds.
+- **Short, Replayable Sessions:**  
+  Each game is designed for quick, fun playthroughs (~5 minutes), making it perfect for demos and repeated experimentation.
+- **Fast and Immersive:**  
+  Instant feedback for user choices (responses in under 5 seconds) and high-quality assets generated in the background.  
+  Atmospheric audio and multiple possible endings are included for full immersion.
+- **Creative Freedom:**  
+  Anyone can build a game from their own story idea or inspiration. Share your creation or play games made by others.
+
+## Why LLMGameHub?
+
+We believe AI should be a creative partner. With LLMGameHub, you don't just play games — you shape them, experiment with genres, and explore what's possible when human imagination meets the latest in generative AI.  
+Bring your story to life — or let AI surprise you!
+
+## How does it work?
+
+1. **Start:** Choose a game genre, world setting, and main character.
+2. **Co-Create:** Answer a few simple questions or pick from suggestions.  
+3. **Watch the Magic:** The AI agents generate a unique story, visuals, audio, and game flow based on your choices.
+4. **Play:** Dive into your own visual novel, make decisions, and explore different endings.
+5. **Share:** Save and share your favorite games with friends (feature coming soon).
+
+---
+
+**LLMGameHub** — Create. Play. Imagine.

requirements.txt

@@ -0,0 +1,16 @@
+gradio==5.32.0
+google-genai==1.18.0
+Pillow==10.1.0
+requests==2.31.0
+python-dotenv==1.0.0
+asyncio
+aiohttp==3.9.1 
+pygame==2.5.2 
+numpy
+langchain==0.3.17
+langchain-core==0.3.58
+langchain-community==0.3.16
+langchain-google-genai==2.1.4
+pydantic-core==2.23.4
+pydantic-settings==2.7.1
+pydantic==2.9.2

src/agent/llm.py

@@ -0,0 +1,43 @@
+from langchain_google_genai import ChatGoogleGenerativeAI
+import logging
+from config import settings
+
+logger = logging.getLogger(__name__)
+
+_google_api_keys_list = []
+_current_google_key_idx = 0
+
+
+def create_llm(temperature: float = settings.temperature, top_p: float = settings.top_p):
+    global _google_api_keys_list, _current_google_key_idx
+
+    if not _google_api_keys_list:
+        api_keys_str = settings.gemini_api_key.get_secret_value()
+        if api_keys_str:
+            _google_api_keys_list = [key.strip() for key in api_keys_str.split(',') if key.strip()]
+        
+        if not _google_api_keys_list:
+            logger.error("Google API keys are not configured or are empty in settings.")
+            raise ValueError("Google API keys are not configured or are invalid for round-robin.")
+
+    if not _google_api_keys_list: # Safeguard, though previous block should handle it.
+        logger.error("No Google API keys available for round-robin.")
+        raise ValueError("No Google API keys available for round-robin.")
+
+    key_index_to_use = _current_google_key_idx
+    selected_api_key = _google_api_keys_list[key_index_to_use]
+    
+    _current_google_key_idx = (key_index_to_use + 1) % len(_google_api_keys_list)
+    
+    logger.info(f"Using Google API key at index {key_index_to_use} (ending with ...{selected_api_key[-4:] if len(selected_api_key) > 4 else selected_api_key}) for round-robin.")
+
+    return ChatGoogleGenerativeAI(
+        model="gemini-2.5-flash-preview-05-20",
+        google_api_key=selected_api_key,
+        temperature=temperature,
+        top_p=top_p,
+        thinking_budget=1024
+    )
+
+def create_precise_llm():
+    return create_llm(temperature=0, top_p=1)

src/agent/llm_agent.py

@@ -0,0 +1,38 @@
+from agent.llm import create_llm
+from pydantic import BaseModel, Field
+from typing import Optional, List
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ChangeScene(BaseModel):
+    change_scene: bool = Field(description="Whether the scene should be changed")
+    scene_description: Optional[str] = None
+    
+class ChangeMusic(BaseModel):
+    change_music: bool = Field(description="Whether the music should be changed")
+    music_description: Optional[str] = None
+    
+class PlayerOption(BaseModel):
+    option_description: str = Field(description="The description of the option, Examples: [Change location] Go to the forest; [Say] Hello!")
+    
+class LLMOutput(BaseModel):
+    change_scene: ChangeScene
+    change_music: ChangeMusic
+    game_message: str = Field(description="The message to the player, Example: You entered the forest, and you see unknown scary creatures. What do you do?")
+    player_options: List[PlayerOption] = Field(description="The list of up to 3 options for the player to choose from.")
+    
+llm = create_llm().with_structured_output(LLMOutput)
+
+async def process_user_input(input: str) -> LLMOutput:
+    """
+    Process user input and update the state.
+    """
+    logger.info(f"User's choice: {input}")
+    
+    response: LLMOutput = await llm.ainvoke(input)
+    
+    logger.info(f"LLM response: {response}")
+    
+    return response
+    

src/agent/llm_graph.py

@@ -0,0 +1,14 @@
+from agent.tools import available_tools
+from agent.llm import create_llm
+from langgraph.graph import MessagesState
+class CustomState(MessagesState):
+    """Расширенное состояние графа."""
+
+
+
+llm = create_llm().bind_tools(available_tools)
+
+
+
+
+

src/agent/tools.py

@@ -0,0 +1,40 @@
+from langchain_core.tools import tool
+from typing import Annotated, Any, Dict, List
+from images.image_generator import generate_image
+from langgraph.prebuilt import InjectedState
+import logging
+
+logger = logging.getLogger(__name__)
+
+def _err(msg: str) -> str:
+    logger.error(msg)
+    return f"{{ 'error': '{msg}' }}"
+
+def _success(msg: str) -> str:
+    logger.info(msg)
+    return f"{{ 'success': '{msg}' }}"
+
+@tool
+async def generate_scene_image(
+    prompt: Annotated[
+        str,
+        "The prompt to generate an image from"
+    ],
+    state: InjectedState,
+) -> Annotated[
+    str,
+    "The path to the generated image"
+]:
+    """
+    Generate an image from a prompt and set current scene image.
+    """
+    try:
+        image_path, img_description = generate_image(prompt)
+        state["current_scene"]["image"] = image_path
+        state["current_scene"]["image_description"] = img_description
+        return _success(f"Image generated and set as current scene image: {img_description}")
+    except Exception as e:
+        return _err(str(e))
+    
+    
+available_tools = [generate_scene_image]

src/audio/audio_generator.py

@@ -0,0 +1,103 @@
+import asyncio
+from google import genai
+from google.genai import types
+from config import settings
+import os
+import tempfile
+import wave
+import numpy as np
+import queue
+import logging
+import gradio as gr
+
+logger = logging.getLogger(__name__)
+
+client = genai.Client(api_key=settings.gemini_api_key.get_secret_value(), http_options={'api_version': 'v1alpha'})
+audio_queue = queue.Queue(maxsize=1)
+
+async def generate_music(request: gr.Request, receive_audio):
+      async with (
+        client.aio.live.music.connect(model='models/lyria-realtime-exp') as session,
+        asyncio.TaskGroup() as tg,
+      ):
+        # Set up task to receive server messages.
+        tg.create_task(receive_audio(session))
+
+        # Send initial prompts and config
+        await session.set_weighted_prompts(
+          prompts=[
+            types.WeightedPrompt(text='The mysterious music of the forest', weight=1.0),
+          ]
+        )
+        await session.set_music_generation_config(
+          config=types.LiveMusicGenerationConfig(bpm=90, temperature=1.0)
+        )
+        await session.play()
+        logger.info(f"Started music generation for session {request.session_hash}")
+        sessions[request.session_hash] = session
+        
+async def change_music_tone(request: gr.Request, new_tone):
+    logger.info(f"Changing music tone to {new_tone}")
+    session = sessions.get(request.session_hash)
+    if not session:
+        logger.error(f"No session found for request {request.session_hash}")
+        return
+    await session.reset_context()
+    await session.set_weighted_prompts(
+        prompts=[types.WeightedPrompt(text=new_tone, weight=1.0)]
+    )
+        
+
+SAMPLE_RATE = 48000
+
+async def receive_audio(session):
+    """Process incoming audio from the music generation."""
+    while True:
+        try:
+            async for message in session.receive():
+                if message.server_content and message.server_content.audio_chunks:
+                    audio_data = message.server_content.audio_chunks[0].data
+                    audio_queue.put(audio_data)
+                await asyncio.sleep(10**-12)
+        except Exception as e:
+            logger.error(f"Error in receive_audio: {e}")
+            await asyncio.sleep(1)
+
+sessions = {}
+
+async def start_music_generation(request: gr.Request):
+    """Start the music generation in a separate thread."""
+    await generate_music(request, receive_audio)
+    
+async def cleanup_music_session(request: gr.Request):
+    if request.session_hash in sessions:
+        logger.info(f"Cleaning up music session for session {request.session_hash}")
+        await sessions[request.session_hash].stop()
+        del sessions[request.session_hash]
+    
+current_audio_file = None
+
+def update_audio():
+    """Continuously stream audio from the queue."""
+    global current_audio_file
+    while True:
+        audio_data = audio_queue.get()
+        if isinstance(audio_data, bytes):
+            audio_array = np.frombuffer(audio_data, dtype=np.int16)
+        else:
+            audio_array = np.array(audio_data, dtype=np.int16)
+            
+        temp_fd, temp_path = tempfile.mkstemp(suffix='.wav')
+        os.close(temp_fd)
+        # Write to WAV file
+        with wave.open(temp_path, 'wb') as wav_file:
+            wav_file.setnchannels(2)  # Stereo
+            wav_file.setsampwidth(2)  # 16-bit
+            wav_file.setframerate(SAMPLE_RATE)
+            wav_file.writeframes(audio_array.tobytes())
+            
+        if current_audio_file:
+            os.remove(current_audio_file)
+            
+        current_audio_file = temp_path
+        yield temp_path

src/config.py

@@ -0,0 +1,28 @@
+from dotenv import load_dotenv
+
+load_dotenv()
+from pydantic_settings import BaseSettings
+import logging
+from pydantic import SecretStr
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(levelname)s:\t%(asctime)s [%(name)s] %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S %z",
+)
+
+class BaseAppSettings(BaseSettings):
+    """Base settings class with common configuration."""
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+    
+class AppSettings(BaseAppSettings):
+    gemini_api_key: SecretStr
+    top_p: float = 0.95
+    temperature: float = 0.5
+    
+
+settings = AppSettings()

src/css.py

@@ -0,0 +1,126 @@
+# Custom CSS for fullscreen image with overlay
+custom_css = """
+/* Make the image container fullscreen */
+.image-container {
+    position: fixed !important;
+    top: 0 !important;
+    left: 0 !important;
+    width: 100vw !important;
+    height: 100vh !important;
+    z-index: 1 !important;
+}
+
+.image-container img {
+    width: 100vw !important;
+    height: 100vh !important;
+    object-fit: cover !important;
+}
+
+/* Style the overlay content */
+.overlay-content {
+    position: fixed !important;
+    bottom: 0 !important;
+    left: 0 !important;
+    right: 0 !important;
+    background: linear-gradient(transparent, rgba(0,0,0,0.8)) !important;
+    padding: 40px 20px 20px !important;
+    z-index: 10 !important;
+    color: white !important;
+}
+
+/* Style the narrative text */
+.narrative-text {
+    background: rgba(0,0,0,0.7) !important;
+    border: none !important;
+    color: white !important;
+    font-size: 18px !important;
+    line-height: 1.5 !important;
+    padding: 20px !important;
+    border-radius: 10px !important;
+    margin-bottom: 20px !important;
+}
+
+img {
+    pointer-events: none;
+}
+
+.narrative-text textarea {
+    background: transparent !important;
+    border: none !important;
+    color: white !important;
+    -webkit-text-fill-color: white !important;
+    font-size: 18px !important;
+    resize: none !important;
+}
+
+/* Style the choice buttons */
+.choice-buttons {
+    background: rgba(0,0,0,0.7) !important;
+    border-radius: 10px !important;
+    padding: 15px !important;
+}
+
+.choice-buttons label {
+    color: white !important;
+    font-size: 16px !important;
+    margin-bottom: 10px !important;
+}
+
+/* Fix radio button backgrounds */
+.choice-buttons input[type="radio"] {
+    background: transparent !important;
+    border: 2px solid white !important;
+}
+
+.choice-buttons input[type="radio"]:checked {
+    background: white !important;
+}
+
+.choice-buttons .form-radio {
+    background: transparent !important;
+}
+
+/* Style radio button containers */
+.choice-buttons > div {
+    background: transparent !important;
+}
+
+.choice-buttons fieldset {
+    background: transparent !important;
+    border: none !important;
+}
+
+/* Remove any remaining white backgrounds */
+.choice-buttons * {
+    background-color: transparent !important;
+}
+
+.choice-buttons input {
+    background-color: transparent !important;
+    border: 1px solid rgba(255,255,255,0.5) !important;
+    color: white !important;
+}
+
+.choice-buttons label span {
+    color: white !important;
+}
+
+/* Hide gradio header and footer */
+.gradio-header, .gradio-footer {
+    display: none !important;
+}
+
+/* Hide image control buttons using correct DOM selector */
+.image-container .icon-button-wrapper {
+    display: none !important;
+}
+
+.image-container .icon-buttons {
+    display: none !important;
+}
+
+/* Make form element transparent */
+.overlay-content .form {
+    background: transparent !important;
+}
+"""

src/game_constructor.py

@@ -0,0 +1,183 @@
+import gradio as gr
+import json
+import uuid
+from game_setting import Character, GameSetting
+from game_state import story, state, get_current_scene
+from agent.llm_agent import process_user_input
+from images.image_generator import generate_image
+
+# Predefined suggestions for demo
+SETTING_SUGGESTIONS = [
+    "A mystical forest shrouded in eternal twilight, where ancient trees whisper secrets and magical creatures roam freely",
+    "A sprawling cyberpunk metropolis in 2099, where neon lights illuminate towering skyscrapers and technology controls every aspect of life",
+    "A Victorian-era mansion on a remote cliff, filled with hidden passages, antique furniture, and an atmosphere of dark mysteries",
+    "A post-apocalyptic wasteland where survivors struggle to rebuild civilization among the ruins of the old world",
+    "A magical academy floating in the clouds, where young wizards learn to master their powers and uncover ancient spells",
+]
+
+CHARACTER_SUGGESTIONS = [
+    {
+        "name": "Elena Nightwhisper",
+        "age": "25",
+        "background": "A skilled detective with supernatural intuition, haunted by visions of crimes before they happen",
+        "personality": "Determined, intuitive, struggles with self-doubt but fiercely protective of the innocent",
+    },
+    {
+        "name": "Marcus Steelborn",
+        "age": "32",
+        "background": "A former soldier turned cybernetic engineer in a dystopian future, seeking to expose corporate corruption",
+        "personality": "Brave, tech-savvy, has trust issues but deeply loyal to those who earn his respect",
+    },
+    {
+        "name": "Aria Moonstone",
+        "age": "19",
+        "background": "A young witch discovering her powers while attending a prestigious magical academy",
+        "personality": "Curious, ambitious, sometimes reckless but has a good heart and strong sense of justice",
+    },
+    {
+        "name": "Dr. Victoria Blackthorne",
+        "age": "45",
+        "background": "A renowned archaeologist who specializes in occult artifacts and ancient mysteries",
+        "personality": "Intelligent, sophisticated, perfectionist with a hidden romantic side",
+    },
+]
+
+GENRE_OPTIONS = [
+    "Horror - Supernatural terror and psychological thrills",
+    "Detective/Mystery - Crime solving and investigation",
+    "Romance - Love stories and relationship drama",
+    "Fantasy - Magic and mythical creatures",
+    "Sci-Fi - Futuristic technology and space exploration",
+    "Adventure - Action-packed journeys and quests",
+    "Psychological Thriller - Mind games and suspense",
+    "Historical Fiction - Stories set in past eras",
+]
+
+
+def load_setting_suggestion(suggestion: str):
+    """Load a predefined setting suggestion"""
+    return suggestion
+
+
+def load_character_suggestion(character_name: str):
+    """Load a predefined character suggestion"""
+    if character_name == "None":
+        return "", "", "", ""
+
+    for char in CHARACTER_SUGGESTIONS:
+        if char["name"] in character_name:
+            return char["name"], char["age"], char["background"], char["personality"]
+    return "", "", "", ""
+
+
+def save_game_config(
+    setting_desc: str,
+    char_name: str,
+    char_age: str,
+    char_background: str,
+    char_personality: str,
+    genre: str,
+):
+    """Save the game configuration to a JSON file"""
+    if not all(
+        [setting_desc, char_name, char_age, char_background, char_personality, genre]
+    ):
+        return "❌ Please fill in all fields before saving."
+
+    config = {
+        "id": str(uuid.uuid4()),
+        "setting": {"description": setting_desc},
+        "character": {
+            "name": char_name,
+            "age": char_age,
+            "background": char_background,
+            "personality": char_personality,
+        },
+        "genre": genre,
+        "created_at": str(uuid.uuid4()),  # In real app, would use actual timestamp
+    }
+
+    try:
+        filename = f"game_config_{config['id'][:8]}.json"
+        with open(f"generated/{filename}", "w") as f:
+            json.dump(config, f, indent=2)
+        return f"✅ Game configuration saved as {filename}"
+    except Exception as e:
+        return f"❌ Error saving configuration: {str(e)}"
+
+async def start_game_with_settings(
+    setting_desc: str,
+    char_name: str,
+    char_age: str,
+    char_background: str,
+    char_personality: str,
+    genre: str,
+):
+    """Initialize the game with custom settings and switch to game interface"""
+    if not all(
+        [setting_desc, char_name, char_age, char_background, char_personality, genre]
+    ):
+        return (
+            gr.update(visible=True),  # constructor_interface
+            gr.update(visible=False),  # game_interface
+            gr.update(
+                value="❌ Please fill in all fields before starting the game.",
+                visible=True,
+            ),  # error_message
+            gr.update(),
+            gr.update(),
+            gr.update(),  # game components unchanged
+        )
+
+    character = Character(
+        name=char_name,
+        age=char_age,
+        background=char_background,
+        personality=char_personality,
+    )
+
+    game_setting = GameSetting(character=character, setting=setting_desc, genre=genre)
+
+    # Initialize the game story with the custom settings
+    initial_story = f"""Welcome to your story, {game_setting.character.name}!
+
+Setting: {game_setting.setting}
+
+You are {game_setting.character.name}, a {game_setting.character.age}-year-old character. {game_setting.character.background}
+
+Your personality: {game_setting.character.personality}
+
+Genre: {game_setting.genre}
+
+You find yourself at the beginning of your adventure. The world around you feels alive with possibilities. What do you choose to do first?
+
+NOTE FOR THE ASSISTANT: YOU HAVE TO GENERATE THE IMAGE FOR THE START SCENE.
+"""
+
+    response = await process_user_input(initial_story)
+
+    img = "forest.jpg"
+    if response.change_scene.change_scene:
+        img_path, _ = await generate_image(response.change_scene.scene_description)
+        if img_path:
+            img = img_path
+
+    story["start"] = {
+        "text": response.game_message,
+        "image": img,
+        "choices": [option.option_description for option in response.player_options],
+        "music_tone": response.change_music.music_description,
+    }
+    state["scene"] = "start"
+
+    # Get the current scene data
+    scene_text, scene_image, scene_choices = get_current_scene()
+
+    return (
+        gr.update(visible=False),  # constructor_interface
+        gr.update(visible=True),  # game_interface
+        gr.update(visible=False),  # error_message
+        gr.update(value=scene_text),  # game_text
+        gr.update(value=scene_image),  # game_image
+        gr.update(choices=scene_choices, value=None),  # game_choices
+    )

src/game_setting.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+class Character(BaseModel):
+    name: str
+    age: str
+    background: str
+    personality: str
+
+class GameSetting(BaseModel):
+    character: Character
+    setting: str
+    genre: str

src/game_state.py

@@ -0,0 +1,15 @@
+
+story = {
+    "start": {
+        "text": "You wake up in a mysterious forest. What do you do?",
+        "image": "forest.jpg",
+        "choices": ["Explore", "Wait"],
+        "music_tone": "neutral",
+    },
+}
+
+state = {"scene": "start"}
+
+def get_current_scene():
+    scene = story[state["scene"]]
+    return scene["text"], scene["image"], scene["choices"]

src/images/image_generator.py

@@ -0,0 +1,140 @@
+from google import genai
+from google.genai import types
+import os
+from PIL import Image
+from io import BytesIO
+from datetime import datetime
+from config import settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+client = genai.Client(api_key=settings.gemini_api_key.get_secret_value())
+
+async def generate_image(prompt: str) -> tuple[str, str] | None:
+    """
+    Generate an image using Google's Gemini model and save it to generated/images directory.
+    
+    Args:
+        prompt (str): The text prompt to generate the image from
+    
+    Returns:
+        str: Path to the generated image file, or None if generation failed
+    """
+    # Ensure the generated/images directory exists
+    output_dir = "generated/images"
+    os.makedirs(output_dir, exist_ok=True)
+
+    try:
+        response = client.models.generate_content(
+            model="gemini-2.0-flash-preview-image-generation",
+            contents=prompt,
+            config=types.GenerateContentConfig(
+                response_modalities=['TEXT', 'IMAGE']
+            )
+        )
+
+        # Process the response parts
+        image_saved = False
+        for part in response.candidates[0].content.parts:
+            if part.text is not None:
+                logger.info(f"Generated text: {part.text}")
+            elif part.inline_data is not None:
+                # Create a filename with timestamp
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"gemini_{timestamp}.png"
+                filepath = os.path.join(output_dir, filename)
+                
+                # Save the image
+                image = Image.open(BytesIO(part.inline_data.data))
+                image.save(filepath, "PNG")
+                logger.info(f"Image saved to: {filepath}")
+                image_saved = True
+                
+                return filepath, part.text
+        
+        if not image_saved:
+            logger.error("No image was generated in the response.")
+            return None, None
+            
+    except Exception as e:
+        logger.error(f"Error generating image: {e}")
+        return None, None
+
+
+def modify_image(image_path: str, modification_prompt: str) -> str | None:
+    """
+    Modify an existing image using Google's Gemini model based on a text prompt.
+    
+    Args:
+        image_path (str): Path to the existing image file
+        modification_prompt (str): The text prompt describing how to modify the image
+    
+    Returns:
+        str: Path to the modified image file, or None if modification failed
+    """
+    # Ensure the generated/images directory exists
+    output_dir = "generated/images"
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Check if the input image exists
+    if not os.path.exists(image_path):
+        logger.error(f"Error: Image file not found at {image_path}")
+        return None
+    
+    key = settings.gemini_api_key.get_secret_value()
+    
+    client = genai.Client(api_key=key)
+
+    try:
+        # Load the input image
+        input_image = Image.open(image_path)
+        
+        # Make the API call with both text and image
+        response = client.models.generate_content(
+            model="gemini-2.0-flash-preview-image-generation",
+            contents=[modification_prompt, input_image],
+            config=types.GenerateContentConfig(
+                response_modalities=['TEXT', 'IMAGE']
+            )
+        )
+
+        # Process the response parts
+        image_saved = False
+        for part in response.candidates[0].content.parts:
+            if part.text is not None:
+                logger.info(f"Generated text: {part.text}")
+            elif part.inline_data is not None:
+                # Create a filename with timestamp
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"gemini_modified_{timestamp}.png"
+                filepath = os.path.join(output_dir, filename)
+                
+                # Save the modified image
+                modified_image = Image.open(BytesIO(part.inline_data.data))
+                modified_image.save(filepath, "PNG")
+                logger.info(f"Modified image saved to: {filepath}")
+                image_saved = True
+                
+                return filepath, part.text
+        
+        if not image_saved:
+            logger.error("No modified image was generated in the response.")
+            return None, None
+            
+    except Exception as e:
+        logger.error(f"Error modifying image: {e}")
+        return None, None
+
+
+if __name__ == "__main__":
+    # Example usage
+    sample_prompt = "A Luke Skywalker half height sprite with white background for visual novel game"
+    generated_image_path = generate_image(sample_prompt)
+    
+    # if generated_image_path:
+    #     # Example modification
+    #     modification_prompt = "Now the house is destroyed, and the jawas are running away"
+    #     modified_image_path = modify_image(generated_image_path, modification_prompt)
+    #     if modified_image_path:
+    #         print(f"Successfully modified image: {modified_image_path}") 

src/main.py

@@ -0,0 +1,320 @@
+import gradio as gr
+from css import custom_css
+from audio.audio_generator import (
+    update_audio,
+    start_music_generation,
+    change_music_tone,
+    cleanup_music_session,
+)
+import logging
+from agent.llm_agent import process_user_input
+from images.image_generator import generate_image
+import uuid
+from game_state import story, state
+from game_constructor import (
+    SETTING_SUGGESTIONS,
+    CHARACTER_SUGGESTIONS,
+    GENRE_OPTIONS,
+    load_setting_suggestion,
+    load_character_suggestion,
+    start_game_with_settings,
+)
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+
+def return_to_constructor():
+    """Return to the game constructor interface"""
+    return (
+        gr.update(visible=True),  # constructor_interface
+        gr.update(visible=False),  # game_interface
+        gr.update(visible=False),  # error_message
+    )
+
+
+async def update_scene(request: gr.Request, choice):
+    logger.info(f"Updating scene with choice: {choice}")
+    if isinstance(choice, str):
+        old_scene = state["scene"]
+        new_scene = str(uuid.uuid4())
+        story[new_scene] = {
+            **story[old_scene],
+        }
+        state["scene"] = new_scene
+
+        user_story = f"""Current scene description:
+            {story[old_scene]["text"]}
+            User's choice: {choice}
+        """
+
+        response = await process_user_input(user_story)
+
+        story[new_scene]["text"] = response.game_message
+
+        story[new_scene]["choices"] = [
+            option.option_description for option in response.player_options
+        ]
+
+        if response.change_scene.change_scene:
+            img_path, _ = await generate_image(response.change_scene.scene_description)
+            if img_path:
+                story[new_scene]["image"] = img_path
+
+        if response.change_music.change_music:
+            await change_music_tone(request, response.change_music.music_description)
+
+    scene = story[state["scene"]]
+    return (
+        scene["text"],
+        scene["image"],
+        gr.Radio(
+            choices=scene["choices"],
+            label="What do you choose?",
+            value=None,
+            elem_classes=["choice-buttons"],
+        ),
+    )
+
+
+def update_preview(setting, name, age, background, personality, genre):
+    """Update the configuration preview"""
+    if not any([setting, name, age, background, personality]):
+        return "Fill in the fields to see a preview..."
+
+    preview = f"""🌍 SETTING: {setting[:100]}{"..." if len(setting) > 100 else ""}
+
+👤 CHARACTER: {name} (Age: {age})
+📖 Background: {background}
+💭 Personality: {personality}
+
+🎭 GENRE: {genre}"""
+    return preview
+
+
+async def start_game_with_music(
+    request: gr.Request,
+    setting_desc: str,
+    char_name: str,
+    char_age: str,
+    char_background: str,
+    char_personality: str,
+    genre: str,
+):
+    """Start the game with custom settings and initialize music"""
+    # First, get the game interface updates
+    result = await start_game_with_settings(
+        setting_desc, char_name, char_age, char_background, char_personality, genre
+    )
+    # If game is starting successfully (interface is switching), start music
+    if len(result) >= 2 and result[1].get(
+        "visible", False
+    ):  # game_interface becoming visible
+        asyncio.create_task(start_music_generation(request))
+
+    if state["scene"] in story and "music_tone" in story[state["scene"]]:
+        await change_music_tone(request, story[state["scene"]]["music_tone"])
+
+    return result
+
+with gr.Blocks(
+    theme="soft", title="Game Constructor & Visual Novel", css=custom_css
+) as demo:
+    # Constructor Interface (visible by default)
+    with gr.Column(visible=True, elem_id="constructor-interface") as constructor_interface:
+        gr.Markdown("# 🎮 Interactive Game Constructor")
+        gr.Markdown(
+            "Create your own interactive story game by defining the setting, character, and genre!"
+        )
+
+        # Error message area
+        error_message = gr.Textbox(
+            label="⚠️ Error",
+            visible=False,
+            interactive=False,
+            elem_classes=["error-message"],
+        )
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Setting Description Section
+                with gr.Group():
+                    gr.Markdown("## 🌍 Setting Description")
+                    setting_suggestions = gr.Dropdown(
+                        choices=["Select a suggestion..."] + SETTING_SUGGESTIONS,
+                        label="Quick Suggestions",
+                        value="Select a suggestion...",
+                        interactive=True,
+                    )
+                    setting_description = gr.Textbox(
+                        label="Describe your game setting",
+                        placeholder="Enter a detailed description of where your story takes place...",
+                        lines=4,
+                        max_lines=6,
+                    )
+
+                # Character Description Section
+                with gr.Group():
+                    gr.Markdown("## 👤 Character Description")
+                    character_suggestions = gr.Dropdown(
+                        choices=["None"]
+                        + [
+                            f"{char['name']} - {char['background'][:50]}..."
+                            for char in CHARACTER_SUGGESTIONS
+                        ],
+                        label="Character Templates",
+                        value="None",
+                        interactive=True,
+                    )
+
+                    with gr.Row():
+                        char_name = gr.Textbox(
+                            label="Character Name",
+                            placeholder="Enter character name...",
+                        )
+                        char_age = gr.Textbox(label="Age", placeholder="25")
+
+                    char_background = gr.Textbox(
+                        label="Background/Profession",
+                        placeholder="Describe your character's background, profession, or role...",
+                        lines=2,
+                    )
+                    char_personality = gr.Textbox(
+                        label="Personality & Traits",
+                        placeholder="Describe personality, quirks, motivations, fears...",
+                        lines=2,
+                    )
+
+                # Genre Selection Section
+                with gr.Group():
+                    gr.Markdown("## 🎭 Genre & Style")
+                    genre_selection = gr.Dropdown(
+                        choices=GENRE_OPTIONS,
+                        label="Choose your story genre",
+                        value=GENRE_OPTIONS[0],
+                        interactive=True,
+                    )
+
+            with gr.Column(scale=1):
+                # Preview Section
+                with gr.Group():
+                    gr.Markdown("## 📋 Configuration Preview")
+                    preview_box = gr.Textbox(
+                        label="Game Summary",
+                        lines=8,
+                        interactive=False,
+                        placeholder="Fill in the fields to see a preview...",
+                    )
+
+                with gr.Group():
+                    gr.Markdown("## 🎮 Ready to Play?")
+                    start_btn = gr.Button("▶️ Start Game", variant="primary", size="lg")
+
+    with gr.Column(visible=False, elem_id="game-interface") as game_interface:
+        gr.Markdown("# 🎮 Your Interactive Story")
+
+        with gr.Row():
+            back_btn = gr.Button("⬅️ Back to Constructor", variant="secondary")
+            gr.Markdown("### Playing your custom game!")
+
+        # Audio component for background music
+        audio_out = gr.Audio(
+            autoplay=True, streaming=True, interactive=False, visible=False
+        )
+
+        # Background image (fullscreen)
+        with gr.Column(elem_classes=["image-container"]):
+            game_image = gr.Image(type="filepath", interactive=False, show_label=False)
+
+        # Overlay content (text and buttons)
+        with gr.Column(elem_classes=["overlay-content"]):
+            game_text = gr.Textbox(
+                label="",
+                interactive=False,
+                show_label=False,
+                elem_classes=["narrative-text"],
+                lines=3,
+            )
+            game_choices = gr.Radio(
+                choices=[],
+                label="What do you choose?",
+                value=None,
+                elem_classes=["choice-buttons"],
+            )
+
+    # Event handlers for constructor interface
+    setting_suggestions.change(
+        fn=load_setting_suggestion,
+        inputs=[setting_suggestions],
+        outputs=[setting_description],
+    )
+
+    character_suggestions.change(
+        fn=load_character_suggestion,
+        inputs=[character_suggestions],
+        outputs=[char_name, char_age, char_background, char_personality],
+    )
+
+    # Update preview when any field changes
+    for component in [
+        setting_description,
+        char_name,
+        char_age,
+        char_background,
+        char_personality,
+        genre_selection,
+    ]:
+        component.change(
+            fn=update_preview,
+            inputs=[
+                setting_description,
+                char_name,
+                char_age,
+                char_background,
+                char_personality,
+                genre_selection,
+            ],
+            outputs=[preview_box],
+        )
+
+    # Interface switching handlers
+    start_btn.click(
+        fn=start_game_with_music,
+        inputs=[
+            setting_description,
+            char_name,
+            char_age,
+            char_background,
+            char_personality,
+            genre_selection,
+        ],
+        outputs=[
+            constructor_interface,
+            game_interface,
+            error_message,
+            game_text,
+            game_image,
+            game_choices,
+        ],
+    )
+
+    back_btn.click(
+        fn=return_to_constructor,
+        inputs=[],
+        outputs=[constructor_interface, game_interface, error_message],
+    )
+
+    game_choices.change(
+        fn=update_scene,
+        inputs=[game_choices],
+        outputs=[game_text, game_image, game_choices],
+    )
+
+    demo.unload(cleanup_music_session)
+    demo.load(
+        fn=update_audio,
+        inputs=None,
+        outputs=[audio_out],
+    )
+
+demo.launch()