Spaces:
Running
Running
| import gradio as gr | |
| import pixeltable as pxt | |
| import numpy as np | |
| from datetime import datetime | |
| from pixeltable.functions.huggingface import sentence_transformer | |
| from pixeltable.functions import openai | |
| import os | |
| import getpass | |
| import re | |
| # 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') | |
| 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 your response in two clearly separated sections using exactly this format: | |
| STORY: [Your engaging narrative response to the player's action] | |
| OPTIONS: | |
| 1. [A dialogue option] | |
| 2. [A random action they could take] | |
| 3. [A unique or unexpected choice]""" | |
| }, | |
| { | |
| 'role': 'user', | |
| 'content': f"Current scenario: {initial_scenario}\n" | |
| f"Player's action: {player_input}\n" | |
| f"Turn number: {turn_number}\n\n" | |
| "Provide the story response and options:" | |
| } | |
| ] | |
| def get_story(response: str) -> str: | |
| """Extract just the story part from the response""" | |
| parts = response.split("OPTIONS:") | |
| if len(parts) != 2: | |
| return response | |
| story = parts[0].replace("STORY:", "").strip() | |
| return story | |
| def get_options(response: str) -> list[str]: | |
| """Extract the options from the response""" | |
| parts = response.split("OPTIONS:") | |
| if len(parts) != 2: | |
| return ["Continue...", "Take another action", "Try something else"] | |
| options = re.findall(r'\d\.\s*(.*?)(?=\d\.|$)', parts[1], re.DOTALL) | |
| options = [opt.strip() for opt in options[:3]] | |
| while len(options) < 3: | |
| options.append("Take another action...") | |
| return options | |
| # Create a single table for all game data | |
| interactions = pxt.create_table( | |
| 'ai_rpg.interactions', | |
| { | |
| 'session_id': pxt.String, | |
| 'player_name': pxt.String, | |
| 'genre': pxt.String, | |
| 'initial_scenario': pxt.String, | |
| 'turn_number': pxt.Int, | |
| 'player_input': pxt.String, | |
| 'timestamp': pxt.Timestamp, | |
| } | |
| ) | |
| # Add computed columns for AI responses | |
| interactions.add_computed_column(messages=generate_messages( | |
| interactions.genre, | |
| interactions.player_name, | |
| interactions.initial_scenario, | |
| interactions.player_input, | |
| interactions.turn_number | |
| )) | |
| interactions.add_computed_column(ai_response=openai.chat_completions( | |
| messages=interactions.messages, | |
| model='gpt-4o-mini-2024-07-18', | |
| max_tokens=500, | |
| temperature=0.8 | |
| )) | |
| interactions.add_computed_column(full_response=interactions.ai_response.choices[0].message.content) | |
| interactions.add_computed_column(story_text=get_story(interactions.full_response)) | |
| interactions.add_computed_column(options=get_options(interactions.full_response)) | |
| 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) -> tuple[str, str, list[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 | |
| 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() | |
| }]) | |
| result = interactions.select( | |
| interactions.story_text, | |
| interactions.options | |
| ).where( | |
| (interactions.session_id == session_id) & | |
| (interactions.turn_number == 0) | |
| ).collect() | |
| return session_id, result['story_text'][0], result['options'][0] | |
| def process_action(self, action: str) -> tuple[str, list[str]]: | |
| if not self.current_session_id: | |
| return "No active game session. Please start a new game.", [] | |
| self.turn_number += 1 | |
| 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() | |
| 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() | |
| }]) | |
| result = interactions.select( | |
| interactions.story_text, | |
| interactions.options | |
| ).where( | |
| (interactions.session_id == self.current_session_id) & | |
| (interactions.turn_number == self.turn_number) | |
| ).collect() | |
| return result['story_text'][0], result['options'][0] | |
| def create_interface(): | |
| game = RPGGame() | |
| with gr.Blocks(theme=gr.themes.Base()) as demo: | |
| 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> | |
| """ | |
| ) | |
| 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: | |
| 1. 🎮 Creates dynamic, AI-driven interactive stories | |
| 2. 🔄 Maintains game state and history using Pixeltable tables | |
| 3. 💭 Generates contextual options based on player actions | |
| 4. 🤖 Uses LLMs to create engaging narratives | |
| 5. 📊 Tracks and displays game progression | |
| """) | |
| 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 choices and generates | |
| contextual responses in real-time | |
| """) | |
| with gr.Row(): | |
| 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") | |
| with gr.Column(): | |
| story_display = gr.Textbox( | |
| label="📜 Story", | |
| lines=8, | |
| interactive=False | |
| ) | |
| gr.Markdown("### 🎯 Choose Your Action") | |
| action_input = gr.Radio( | |
| choices=[], | |
| label="🎲 Select your next action:", | |
| interactive=True | |
| ) | |
| submit_action = gr.Button("⚡ Take Action", variant="secondary") | |
| 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..."], | |
| ["Elon Musk", "🤖 Cyberpunk", """You're the CEO of Neural Link Industries in Austin, 2049. Your brain-computer interface has started giving users the ability to communicate with their houseplants. As you prepare for a major investor presentation, your AI assistant reports that the test subjects are organizing a peculiar gardening revolution..."""], | |
| ["Gordon Ramsey", "🌋 Post-Apocalyptic", """You're the last master chef in New Neo York, running an underground restaurant in the ruins of a former luxury hotel. Your signature dish requires a rare mushroom that only grows in the dangerous radioactive zones. Just as you're preparing for tonight's secret supper club, your scout returns with troubling news about rival chef gangs in the area..."""], | |
| ], | |
| inputs=[player_name, genre, scenario] | |
| ) | |
| 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_story, initial_options = game.start_game(name, genre_choice, scenario_text) | |
| 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_story, gr.Radio(choices=initial_options, interactive=True), history_data | |
| except Exception as e: | |
| return f"Error starting game: {str(e)}", [], [] | |
| def process_player_action(action_choice): | |
| try: | |
| if not action_choice: | |
| return "Please select an action to continue.", [], [] | |
| story, options = game.process_action(action_choice) | |
| 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 story, gr.Radio(choices=options, interactive=True), history_data | |
| except Exception as e: | |
| return f"Error: {str(e)}", [], [] | |
| start_button.click( | |
| start_new_game, | |
| inputs=[player_name, genre, scenario], | |
| outputs=[story_display, action_input, history_df] | |
| ) | |
| submit_action.click( | |
| process_player_action, | |
| inputs=[action_input], | |
| outputs=[story_display, action_input, history_df] | |
| ) | |
| 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;"> | |
| Open Source AI Data infrastructure. | |
| </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;"> | |
| This work is licensed under the Apache License 2.0. You can freely use, modify, and distribute this code, provided you include appropriate attribution and maintain the original license notice. | |
| </p> | |
| </div> | |
| """ | |
| ) | |
| return demo | |
| if __name__ == "__main__": | |
| demo = create_interface() | |
| demo.launch() |