Upload 6 files

interface/app.py

@@ -0,0 +1,245 @@
+import gradio as gr
+from src.game_logic import RPGGame
+from src.database import interactions
+
+def create_interface():
+    game = RPGGame()
+    
+    with gr.Blocks(theme=gr.themes.Base()) as demo:
+        # Header with title and description
+        gr.Markdown(
+            """
+            <div style="margin-bottom: 20px;">
+                <h1 style="margin-bottom: 0.5em;">🎲 AI RPG Adventure</h1>
+                <p>An interactive RPG experience from Pixeltable and powered by OpenAI! Get started with an example below.</p>
+            </div>
+            """
+        )
+        
+        # Side-by-side accordions
+        with gr.Row():
+            with gr.Column():
+                with gr.Accordion("🎯 What does it do?", open=False):
+                    gr.Markdown("""
+                    This AI RPG Adventure demonstrates Pixeltable's capabilities:
+                    
+                    - 🎮 Creates dynamic, AI-driven interactive stories
+                    - 🔄 Maintains game state and history using Pixeltable tables 
+                    - 💭 Generates contextual options based on player actions
+                    - 📝 Processes natural language inputs for custom actions
+                    - 🤖 Uses LLMs to create engaging narratives
+                    - 📊 Tracks and displays game progression
+                    
+                    Perfect for understanding how Pixeltable can manage complex,
+                    stateful applications with AI integration! ✨
+                    """)
+            
+            with gr.Column():
+                with gr.Accordion("🛠️ How does it work?", open=False):
+                    gr.Markdown("""
+                    The app leverages several Pixeltable features:
+                    
+                    1. 📦 **Data Management**: Uses Pixeltable tables to store game state, 
+                       player actions, and AI responses
+                    
+                    2. 🤖 **AI Integration**: Seamlessly connects with language models 
+                       for story generation and response processing
+                    
+                    3. 🔄 **State Tracking**: Maintains session history and player 
+                       choices using Pixeltable's computed columns
+                    
+                    4. ⚙️ **Custom Processing**: Uses Pixeltable UDFs to handle game 
+                       logic and AI prompt generation
+                    
+                    5. 🎯 **Interactive Flow**: Processes player inputs and generates 
+                       contextual responses in real-time
+                    """)
+        
+        with gr.Row():
+            # Setup column
+            with gr.Column():
+                player_name = gr.Textbox(
+                    label="👤 Your Character's Name",
+                    placeholder="Enter your character's name..."
+                )
+                genre = gr.Dropdown(
+                    choices=[
+                        "🧙‍♂️ Fantasy",
+                        "🚀 Sci-Fi",
+                        "👻 Horror",
+                        "🔍 Mystery",
+                        "🌋 Post-Apocalyptic",
+                        "🤖 Cyberpunk",
+                        "⚙️ Steampunk"
+                    ],
+                    label="🎭 Choose Your Genre"
+                )
+                scenario = gr.Textbox(
+                    label="📖 Starting Scenario",
+                    lines=3,
+                    placeholder="Describe the initial setting and situation..."
+                )
+                start_button = gr.Button("🎮 Begin Adventure", variant="primary")
+            
+            # Game interaction column
+            with gr.Column():
+                story_display = gr.Textbox(
+                    label="📜 Story",
+                    lines=8,
+                    interactive=False
+                )
+                
+                gr.Markdown("### 🎯 Choose Your Action")
+                
+                with gr.Row():
+                    with gr.Column():
+                        action_input = gr.Radio(
+                            choices=[],
+                            label="🎲 Select an action or write your own below:",
+                            interactive=True
+                        )
+                        custom_action = gr.Textbox(
+                            label="✨ Custom Action",
+                            placeholder="Write your own action here...",
+                            lines=2
+                        )
+                        submit_action = gr.Button("⚡ Take Action", variant="secondary")
+        
+        # History display
+        history_df = gr.Dataframe(
+            headers=["📅 Turn", "🎯 Player Action", "💬 Game Response"],
+            label="📚 Adventure History",
+            wrap=True,
+            row_count=5,
+            col_count=(3, "fixed")
+        )
+        def start_new_game(name, genre_choice, scenario_text):
+            if not name or not genre_choice or not scenario_text:
+                return "Please fill in all fields before starting.", [], "", []
+            
+            try:
+                _, initial_response = game.start_game(name, genre_choice, scenario_text)
+                
+                # Get options from the initial response
+                options = interactions.select(interactions.options).where(
+                    (interactions.session_id == game.current_session_id) & 
+                    (interactions.turn_number == 0)
+                ).collect()['options'][0]
+                
+                # Get initial history
+                history_df = interactions.select(
+                    turn=interactions.turn_number,
+                    action=interactions.player_input,
+                    response=interactions.story_text
+                ).where(
+                    interactions.session_id == game.current_session_id
+                ).order_by(
+                    interactions.turn_number
+                ).collect().to_pandas()
+                
+                history_data = [
+                    [str(row['turn']), row['action'], row['response']] 
+                    for _, row in history_df.iterrows()
+                ]
+                
+                return initial_response, gr.Radio(choices=options, interactive=True), "", history_data
+            except Exception as e:
+                return f"Error starting game: {str(e)}", [], "", []
+        
+        def process_player_action(action_choice, custom_action):
+            try:
+                # Use custom action if provided, otherwise use selected choice
+                action = custom_action if custom_action else action_choice
+                if not action:
+                    return "Please either select an action or write your own.", [], "", []
+                    
+                response = game.process_action(action)
+                
+                # Get new options
+                options = interactions.select(interactions.options).where(
+                    (interactions.session_id == game.current_session_id) & 
+                    (interactions.turn_number == game.turn_number)
+                ).collect()['options'][0]
+                
+                # Get updated history
+                history_df = interactions.select(
+                    turn=interactions.turn_number,
+                    action=interactions.player_input,
+                    response=interactions.story_text
+                ).where(
+                    interactions.session_id == game.current_session_id
+                ).order_by(
+                    interactions.turn_number
+                ).collect().to_pandas()
+                
+                history_data = [
+                    [str(row['turn']), row['action'], row['response']] 
+                    for _, row in history_df.iterrows()
+                ]
+                
+                return response, gr.Radio(choices=options, interactive=True), "", history_data
+            except Exception as e:
+                return f"Error: {str(e)}", [], "", []
+        
+        # Connect the start button
+        start_button.click(
+            start_new_game,
+            inputs=[player_name, genre, scenario],
+            outputs=[story_display, action_input, custom_action, history_df]
+        )
+        
+        # Single action submit button
+        submit_action.click(
+            process_player_action,
+            inputs=[action_input, custom_action],
+            outputs=[story_display, action_input, custom_action, history_df]
+        )
+        
+               # Example scenarios
+        gr.Markdown("### 💫 Example Adventures")
+        gr.Examples(
+            examples=[
+                ["Eldric", "🧙‍♂️ Fantasy", "You find yourself in an ancient forest clearing, standing before a mysterious glowing portal. Your journey begins..."],
+                ["Commander Nova", "🚀 Sci-Fi", "Aboard the starship Nebula, alarms blare as unknown entities approach. The fate of the crew rests in your hands..."],
+                ["Detective Blake", "🔍 Mystery", "In the fog-shrouded streets of Victorian London, a peculiar letter arrives at your doorstep..."],
+            ],
+            inputs=[player_name, genre, scenario]
+        )
+        
+        # Footer with links
+        gr.HTML(
+            """
+            <div style="margin-top: 2rem; padding-top: 1rem; border-top: 1px solid #e5e7eb;">
+                <div style="display: flex; justify-content: space-between; align-items: center; flex-wrap: wrap; gap: 1rem;">
+                    <div style="flex: 1;">
+                        <h4 style="margin: 0; color: #374151;">🚀 Built with Pixeltable</h4>
+                        <p style="margin: 0.5rem 0; color: #6b7280;">
+                            AI Data infrastructure providing a declarative, incremental approach for multimodal workloads.
+                        </p>
+                    </div>
+                    <div style="flex: 1;">
+                        <h4 style="margin: 0; color: #374151;">🔗 Resources</h4>
+                        <div style="display: flex; gap: 1.5rem; margin-top: 0.5rem;">
+                            <a href="https://github.com/pixeltable/pixeltable" target="_blank" style="color: #4F46E5; text-decoration: none; display: flex; align-items: center; gap: 0.25rem;">
+                                💻 GitHub
+                            </a>
+                            <a href="https://docs.pixeltable.com" target="_blank" style="color: #4F46E5; text-decoration: none; display: flex; align-items: center; gap: 0.25rem;">
+                                📚 Documentation
+                            </a>
+                            <a href="https://huggingface.co/Pixeltable" target="_blank" style="color: #4F46E5; text-decoration: none; display: flex; align-items: center; gap: 0.25rem;">
+                                🤗 Hugging Face
+                            </a>
+                        </div>
+                    </div>
+                </div>
+                <p style="margin: 1rem 0 0; text-align: center; color: #9CA3AF; font-size: 0.875rem;">
+                    ✨ © 2024 Pixeltable. This demo is open source and available on 
+                    <a href="https://huggingface.co/spaces/Pixeltable/AI-RPG-Adventure" target="_blank" style="color: #4F46E5; text-decoration: none;">
+                        Hugging Face Spaces 🚀
+                    </a>
+                </p>
+            </div>
+            """
+        )
+
+    return demo

src/database.py

@@ -0,0 +1,47 @@
+import pixeltable as pxt
+from pixeltable.functions import openai
+import os
+import getpass
+
+# Set up OpenAI API key
+if 'OPENAI_API_KEY' not in os.environ:
+    os.environ['OPENAI_API_KEY'] = getpass.getpass('Enter your OpenAI API key: ')
+
+# Initialize Pixeltable
+pxt.drop_dir('ai_rpg', force=True)
+pxt.create_dir('ai_rpg')
+
+# Create a single table for all game data
+interactions = pxt.create_table(
+    'ai_rpg.interactions',
+    {
+        'session_id': pxt.StringType(),
+        'player_name': pxt.StringType(),
+        'genre': pxt.StringType(),
+        'initial_scenario': pxt.StringType(),
+        'turn_number': pxt.IntType(),
+        'player_input': pxt.StringType(),
+        'timestamp': pxt.TimestampType(),
+    }
+)
+
+# Add computed columns for AI responses
+from src.utils import generate_messages, extract_options
+
+interactions['messages'] = generate_messages(
+    interactions.genre,
+    interactions.player_name,
+    interactions.initial_scenario,
+    interactions.player_input,
+    interactions.turn_number
+)
+
+interactions['ai_response'] = openai.chat_completions(
+    messages=interactions.messages,
+    model='gpt-4o-mini-2024-07-18',
+    max_tokens=500,
+    temperature=0.8
+)
+
+interactions['story_text'] = interactions.ai_response.choices[0].message.content
+interactions['options'] = extract_options(interactions.story_text)

src/game_logic.py

@@ -0,0 +1,66 @@
+from datetime import datetime
+from src.database import interactions
+
+class RPGGame:
+    def __init__(self):
+        self.current_session_id = None
+        self.turn_number = 0
+    
+    def start_game(self, player_name: str, genre: str, scenario: str) -> str:
+        session_id = f"session_{datetime.now().strftime('%Y%m%d%H%M%S')}_{player_name}"
+        self.current_session_id = session_id
+        self.turn_number = 0
+        
+        # Create initial interaction with all session data
+        interactions.insert([{
+            'session_id': session_id,
+            'player_name': player_name,
+            'genre': genre,
+            'initial_scenario': scenario,
+            'turn_number': 0,
+            'player_input': "Game starts",
+            'timestamp': datetime.now()
+        }])
+        
+        # Get initial story and options
+        initial_response = interactions.select(interactions.story_text).where(
+            (interactions.session_id == session_id) & 
+            (interactions.turn_number == 0)
+        ).collect()['story_text'][0]
+        
+        return session_id, initial_response
+    
+    def process_action(self, action: str) -> str:
+        if not self.current_session_id:
+            return "No active game session. Please start a new game."
+        
+        self.turn_number += 1
+        
+        # Get session info from previous turn
+        prev_turn = interactions.select(
+            interactions.player_name,
+            interactions.genre,
+            interactions.initial_scenario
+        ).where(
+            (interactions.session_id == self.current_session_id) &
+            (interactions.turn_number == 0)
+        ).collect()
+        
+        # Record player action with session data
+        interactions.insert([{
+            'session_id': self.current_session_id,
+            'player_name': prev_turn['player_name'][0],
+            'genre': prev_turn['genre'][0],
+            'initial_scenario': prev_turn['initial_scenario'][0],
+            'turn_number': self.turn_number,
+            'player_input': action,
+            'timestamp': datetime.now()
+        }])
+        
+        # Get AI response
+        response = interactions.select(interactions.story_text).where(
+            (interactions.session_id == self.current_session_id) & 
+            (interactions.turn_number == self.turn_number)
+        ).collect()['story_text'][0]
+        
+        return response

src/utils.py

@@ -0,0 +1,35 @@
+import pixeltable as pxt
+import re
+
+@pxt.udf
+def generate_messages(genre: str, player_name: str, initial_scenario: str, player_input: str, turn_number: int) -> list[dict]:
+    return [
+        {
+            'role': 'system',
+            'content': f"""You are the game master for a {genre} RPG. The player's name is {player_name}. 
+            Provide an engaging response to the player's action and present exactly 3 numbered options for their next move:
+            1. A dialogue option (saying something)
+            2. A random action they could take
+            3. A unique or unexpected choice
+            
+            Format each option with a number (1., 2., 3.) followed by the action description."""
+        },
+        {
+            'role': 'user',
+            'content': f"Current scenario: {initial_scenario}\n"
+                      f"Player's action: {player_input}\n"
+                      f"Turn number: {turn_number}\n\n"
+                      "Provide a response and 3 options:"
+        }
+    ]
+
+@pxt.udf
+def extract_options(story_text: str) -> list[str]:
+    """Extract the three options from the story text"""
+    # Look for numbered options (1., 2., 3.) and grab the text after them
+    options = re.findall(r'\d\.\s*(.*?)(?=\d\.|$)', story_text, re.DOTALL)
+    # Clean up the options and ensure we have exactly 3
+    options = [opt.strip() for opt in options[:3]]
+    while len(options) < 3:
+        options.append("Take another action...")
+    return options