Update app.py

app.py

@@ -16,51 +16,66 @@ if 'OPENAI_API_KEY' not in os.environ:
 pxt.drop_dir('ai_rpg', force=True)
 pxt.create_dir('ai_rpg')
 
-# Create a UDF for generating messages
 @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."""
+            '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 a response and 3 options:"
+                      "Provide the story response and 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
+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
+
+@pxt.udf
+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.StringType(),
-        'player_name': pxt.StringType(),
-        'genre': pxt.StringType(),
-        'initial_scenario': pxt.StringType(),
-        'turn_number': pxt.IntType(),
-        'player_input': pxt.StringType(),
-        'timestamp': pxt.TimestampType(),
+        '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,
     }
 )
 
@@ -80,20 +95,20 @@ interactions['ai_response'] = openai.chat_completions(
     temperature=0.8
 )
 
-interactions['story_text'] = interactions.ai_response.choices[0].message.content
-interactions['options'] = extract_options(interactions.story_text)
+interactions['full_response'] = interactions.ai_response.choices[0].message.content
+interactions['story_text'] = get_story(interactions.full_response)
+interactions['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) -> str:
+    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
         
-        # Create initial interaction with all session data
         interactions.insert([{
             'session_id': session_id,
             'player_name': player_name,
@@ -104,21 +119,22 @@ class RPGGame:
             'timestamp': datetime.now()
         }])
         
-        # Get initial story and options
-        initial_response = interactions.select(interactions.story_text).where(
+        result = interactions.select(
+            interactions.story_text,
+            interactions.options
+        ).where(
             (interactions.session_id == session_id) & 
             (interactions.turn_number == 0)
-        ).collect()['story_text'][0]
+        ).collect()
         
-        return session_id, initial_response
+        return session_id, result['story_text'][0], result['options'][0]
     
-    def process_action(self, action: str) -> str:
+    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."
+            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,
@@ -128,7 +144,6 @@ class RPGGame:
             (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],
@@ -139,19 +154,20 @@ class RPGGame:
             'timestamp': datetime.now()
         }])
         
-        # Get AI response
-        response = interactions.select(interactions.story_text).where(
+        result = interactions.select(
+            interactions.story_text,
+            interactions.options
+        ).where(
             (interactions.session_id == self.current_session_id) & 
             (interactions.turn_number == self.turn_number)
-        ).collect()['story_text'][0]
+        ).collect()
         
-        return response
+        return result['story_text'][0], result['options'][0]
 
 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;">
@@ -161,7 +177,6 @@ def create_interface():
             """
         )
         
-        # Side-by-side accordions
         with gr.Row():
             with gr.Column():
                 with gr.Accordion("🎯 What does it do?", open=False):
@@ -171,7 +186,6 @@ def create_interface():
                     - 🎮 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
                     
@@ -196,12 +210,11 @@ def create_interface():
                     4. ⚙️ **Custom Processing**: Uses Pixeltable UDFs to handle game 
                        logic and AI prompt generation
                     
-                    5. 🎯 **Interactive Flow**: Processes player inputs and generates 
+                    5. 🎯 **Interactive Flow**: Processes player choices and generates 
                        contextual responses in real-time
                     """)
         
         with gr.Row():
-            # Setup column
             with gr.Column():
                 player_name = gr.Textbox(
                     label="👤 Your Character's Name",
@@ -226,7 +239,6 @@ def create_interface():
                 )
                 start_button = gr.Button("🎮 Begin Adventure", variant="primary")
             
-            # Game interaction column
             with gr.Column():
                 story_display = gr.Textbox(
                     label="📜 Story",
@@ -236,21 +248,13 @@ def create_interface():
                 
                 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")
-               
-        # Example scenarios
+                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=[
@@ -261,7 +265,6 @@ def create_interface():
             inputs=[player_name, genre, scenario]
         )
         
-        # History display
         history_df = gr.Dataframe(
             headers=["📅 Turn", "🎯 Player Action", "💬 Game Response"],
             label="📚 Adventure History",
@@ -269,20 +272,14 @@ def create_interface():
             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.", [], "", []
+                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]
+                _, initial_story, initial_options = game.start_game(name, genre_choice, scenario_text)
                 
-                # Get initial history
                 history_df = interactions.select(
                     turn=interactions.turn_number,
                     action=interactions.player_input,
@@ -298,26 +295,17 @@ def create_interface():
                     for _, row in history_df.iterrows()
                 ]
                 
-                return initial_response, gr.Radio(choices=options, interactive=True), "", history_data
+                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, custom_action):
+                return f"Error starting game: {str(e)}", [], []
+
+        def process_player_action(action_choice):
             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.", [], "", []
+                if not action_choice:
+                    return "Please select an action to continue.", [], []
                     
-                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]
+                story, options = game.process_action(action_choice)
                 
-                # Get updated history
                 history_df = interactions.select(
                     turn=interactions.turn_number,
                     action=interactions.player_input,
@@ -333,25 +321,22 @@ def create_interface():
                     for _, row in history_df.iterrows()
                 ]
                 
-                return response, gr.Radio(choices=options, interactive=True), "", history_data
+                return story, gr.Radio(choices=options, interactive=True), history_data
             except Exception as e:
-                return f"Error: {str(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]
+            outputs=[story_display, action_input, 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]
+            inputs=[action_input],
+            outputs=[story_display, action_input, history_df]
         )
         
-        # Footer with links
         gr.HTML(
             """
             <div style="margin-top: 2rem; padding-top: 1rem; border-top: 1px solid #e5e7eb;">