Update app.py

app.py

@@ -18,7 +18,7 @@ if 'OPENAI_API_KEY' not in os.environ:
 pxt.drop_dir('ai_rpg', force=True)
 pxt.create_dir('ai_rpg')
 
-# Regular function (not UDF)
+# Regular function (not UDF) for initializing stats
 def initialize_stats(genre: str) -> str:
     """Initialize player stats based on the selected genre"""
     base_stats = {
@@ -37,6 +37,34 @@ def initialize_stats(genre: str) -> str:
         # Default stats if genre not found
         return "Health: 100, Energy: 100, Strength: 7, Intelligence: 7, Agility: 7, Money: 100"
 
+# Regular Python function for fallback responses (not a UDF)
+def create_fallback_response(player_input: str, turn_number: int) -> dict:
+    """Generate a fallback response when API fails"""
+    if turn_number == 0:
+        story = "Your adventure begins as you assess your surroundings. The world around you seems full of possibilities and dangers alike. What will you do next?"
+        stats = "Your current stats remain unchanged."
+        options = [
+            "Explore the area carefully",
+            "Look for signs of civilization",
+            "Check your inventory",
+            "Rest and gather your thoughts"
+        ]
+    else:
+        story = f"You decide to {player_input}. As you do, you notice new details about your environment and feel yourself making progress in your quest."
+        stats = "Your actions have slightly improved your experience."
+        options = [
+            "Continue on your current path",
+            "Try a different approach",
+            "Investigate something suspicious",
+            "Take a moment to strategize"
+        ]
+    
+    return {
+        "story": story,
+        "stats": stats,
+        "options": options
+    }
+
 @pxt.udf
 def generate_messages(genre: str, player_name: str, initial_scenario: str, player_input: str, turn_number: int, stats: str) -> list[dict]:
     return [
@@ -74,30 +102,6 @@ def generate_messages(genre: str, player_name: str, initial_scenario: str, playe
         }
     ]
 
-@pxt.udf
-def fallback_response(player_input: str, turn_number: int) -> str:
-    """Generate a fallback response when API fails"""
-    if turn_number == 0:
-        return """📜 **STORY**: Your adventure begins as you assess your surroundings. The world around you seems full of possibilities and dangers alike. What will you do next?
-
-📊 **STATS UPDATE**: Your current stats remain unchanged.
-
-🎯 **OPTIONS**:
-1. Explore the area carefully
-2. Look for signs of civilization
-3. Check your inventory
-4. Rest and gather your thoughts"""
-    else:
-        return f"""📜 **STORY**: You decide to {player_input}. As you do, you notice new details about your environment and feel yourself making progress in your quest.
-
-📊 **STATS UPDATE**: Your actions have slightly improved your experience.
-
-🎯 **OPTIONS**:
-1. Continue on your current path
-2. Try a different approach
-3. Investigate something suspicious
-4. Take a moment to strategize"""
-
 @pxt.udf
 def get_story(response: str) -> str:
     """Extract just the story part from the response"""
@@ -156,7 +160,11 @@ interactions = pxt.create_table(
         'player_input': pxt.String,
         'timestamp': pxt.Timestamp,
         'player_stats': pxt.String,
-        'random_event': pxt.String
+        'random_event': pxt.String,
+        'use_fallback': pxt.Boolean,
+        'fallback_story': pxt.String,
+        'fallback_stats': pxt.String,
+        'fallback_options': pxt.String
     }
 )
 
@@ -170,10 +178,10 @@ interactions.add_computed_column(messages=generate_messages(
     interactions.player_stats
 ))
 
-# Changed from gpt-4.1-mini to gpt-3.5-turbo for better compatibility
+# Changed to gpt-3.5-turbo for better compatibility
 interactions.add_computed_column(ai_response=openai.chat_completions(
     messages=interactions.messages,
-    model='gpt-3.5-turbo',  # Changed to a more widely available model
+    model='gpt-3.5-turbo',
     max_tokens=800,
     temperature=0.8
 ))
@@ -189,7 +197,7 @@ class RPGGame:
         self.turn_number = 0
         self.current_stats = ""
     
-    def start_game(self, player_name: str, genre: str, scenario: str) -> tuple[str, str, str, list[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
@@ -198,7 +206,11 @@ class RPGGame:
         initial_stats = initialize_stats(genre)
         self.current_stats = initial_stats
         
+        # Create fallback content just in case
+        fallback = create_fallback_response("Game starts", 0)
+        
         try:
+            # First try without fallback
             interactions.insert([{
                 'session_id': session_id,
                 'player_name': player_name,
@@ -207,39 +219,37 @@ class RPGGame:
                 'turn_number': 0,
                 'player_input': "Game starts",
                 'timestamp': datetime.now(),
-                'player_stats': initial_stats,  # Store string result
-                'random_event': ""
+                'player_stats': initial_stats,
+                'random_event': "",
+                'use_fallback': False,
+                'fallback_story': fallback["story"],
+                'fallback_stats': fallback["stats"],
+                'fallback_options': ",".join(fallback["options"])
             }])
             
-            # Added retry logic for API calls
-            max_retries = 3
-            for attempt in range(max_retries):
-                try:
-                    result = interactions.select(
-                        interactions.story_text,
-                        interactions.stats_update,
-                        interactions.options
-                    ).where(
-                        (interactions.session_id == session_id) & 
-                        (interactions.turn_number == 0)
-                    ).collect()
-                    
-                    return session_id, result['story_text'][0], result['stats_update'][0], result['options'][0]
-                except Exception as e:
-                    if attempt < max_retries - 1:
-                        time.sleep(2)  # Wait before retrying
-                    else:
-                        # Use fallback response if all retries fail
-                        fallback = fallback_response("Game starts", 0)
-                        return session_id, get_story(fallback), get_stats_update(fallback), get_options(fallback)
+            # Try to get response
+            try:
+                result = interactions.select(
+                    interactions.story_text,
+                    interactions.stats_update,
+                    interactions.options
+                ).where(
+                    (interactions.session_id == session_id) & 
+                    (interactions.turn_number == 0)
+                ).collect()
+                
+                return result['story_text'][0], result['stats_update'][0], result['options'][0]
+            except Exception as e:
+                # If OpenAI fails, use the fallback values
+                return fallback["story"], fallback["stats"], fallback["options"]
+                
         except Exception as e:
-            # Use fallback if insert fails
-            fallback = fallback_response("Game starts", 0)
-            return session_id, get_story(fallback), get_stats_update(fallback), get_options(fallback)
+            # If everything fails, return fallback
+            return fallback["story"], fallback["stats"], fallback["options"]
     
     def process_action(self, action: str) -> tuple[str, str, list[str]]:
         if not self.current_session_id:
-            return "No active game session. Please start a new game.", "No stats", []
+            return "No active game session. Please start a new game.", "No stats", ["Start a new game"]
         
         self.turn_number += 1
         
@@ -273,6 +283,9 @@ class RPGGame:
             if random_event_val:
                 action = f"{action} ({random_event_val})"
             
+            # Create fallback content
+            fallback = create_fallback_response(action, self.turn_number)
+            
             interactions.insert([{
                 'session_id': self.current_session_id,
                 'player_name': prev_turn['player_name'][0],
@@ -282,37 +295,35 @@ class RPGGame:
                 'player_input': action,
                 'timestamp': datetime.now(),
                 'player_stats': self.current_stats,
-                'random_event': random_event_val
+                'random_event': random_event_val,
+                'use_fallback': False,
+                'fallback_story': fallback["story"],
+                'fallback_stats': fallback["stats"],
+                'fallback_options': ",".join(fallback["options"])
             }])
             
-            # Added retry logic for API calls
-            max_retries = 3
-            for attempt in range(max_retries):
-                try:
-                    result = interactions.select(
-                        interactions.story_text,
-                        interactions.stats_update,
-                        interactions.options
-                    ).where(
-                        (interactions.session_id == self.current_session_id) & 
-                        (interactions.turn_number == self.turn_number)
-                    ).collect()
-                    
-                    # Update stats for next turn
-                    self.current_stats = result['stats_update'][0]
-                    
-                    return result['story_text'][0], result['stats_update'][0], result['options'][0]
-                except Exception as e:
-                    if attempt < max_retries - 1:
-                        time.sleep(2)  # Wait before retrying
-                    else:
-                        # Use fallback response if all retries fail
-                        fallback = fallback_response(action, self.turn_number)
-                        return get_story(fallback), get_stats_update(fallback), get_options(fallback)
+            try:
+                result = interactions.select(
+                    interactions.story_text,
+                    interactions.stats_update,
+                    interactions.options
+                ).where(
+                    (interactions.session_id == self.current_session_id) & 
+                    (interactions.turn_number == self.turn_number)
+                ).collect()
+                
+                # Update stats for next turn
+                self.current_stats = result['stats_update'][0]
+                
+                return result['story_text'][0], result['stats_update'][0], result['options'][0]
+            except Exception as e:
+                # If OpenAI fails, use the fallback values
+                return fallback["story"], fallback["stats"], fallback["options"]
+                
         except Exception as e:
-            # Use fallback if something fails
-            fallback = fallback_response(action, self.turn_number)
-            return get_story(fallback), get_stats_update(fallback), get_options(fallback)
+            # If everything fails, use fallback
+            fallback = create_fallback_response(action, self.turn_number)
+            return fallback["story"], fallback["stats"], fallback["options"]
 
 def create_interface():
     game = RPGGame()
@@ -500,33 +511,39 @@ def create_interface():
                 )
             
             try:
-                _, initial_story, initial_stats, 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()
+                initial_story, initial_stats, initial_options = game.start_game(name, genre_choice, scenario_text)
                 
-                history_data = [
-                    [str(row['turn']), row['action'], row['response']] 
-                    for _, row in history_df.iterrows()
-                ]
+                # Try to get history, but if it fails, create empty history
+                try:
+                    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()
+                    ]
+                except Exception as e:
+                    history_data = [["0", "Game starts", initial_story]]
                 
                 story_html = f"<div class='story-container'>{initial_story}</div>"
                 stats_html = f"<div class='stats-container'><h3>📊 Character Status</h3>{initial_stats}</div>"
                 
                 return story_html, stats_html, gr.Radio(choices=initial_options, interactive=True), history_data
             except Exception as e:
+                # Handle any other unexpected errors
+                fallback = create_fallback_response("Game starts", 0)
                 return (
-                    f"<div class='story-container'>Game start error: {str(e)}</div>",
-                    "<div class='stats-container'>No stat information</div>",
-                    [],
-                    []
+                    f"<div class='story-container'>{fallback['story']}</div>",
+                    f"<div class='stats-container'><h3>📊 Character Status</h3>{fallback['stats']}</div>",
+                    gr.Radio(choices=fallback['options'], interactive=True),
+                    [["0", "Game starts", fallback['story']]]
                 )
 
         def process_player_action(action_choice):
@@ -541,31 +558,38 @@ def create_interface():
                     
                 story, stats, 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()
-                ]
+                # Try to get history, but if it fails, create minimal history
+                try:
+                    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()
+                    ]
+                except Exception as e:
+                    # If history retrieval fails, create minimal history
+                    history_data = [[str(game.turn_number), action_choice, story]]
                 
                 story_html = f"<div class='story-container'>{story}</div>"
                 stats_html = f"<div class='stats-container'><h3>📊 Character Status</h3>{stats}</div>"
                 
                 return story_html, stats_html, gr.Radio(choices=options, interactive=True), history_data
             except Exception as e:
+                # Handle any other unexpected errors
+                fallback = create_fallback_response(action_choice, 1)
                 return (
-                    f"<div class='story-container'>Error: {str(e)}</div>",
-                    "<div class='stats-container'>No stat information</div>",
-                    [],
-                    []
+                    f"<div class='story-container'>{fallback['story']}</div>",
+                    f"<div class='stats-container'><h3>📊 Character Status</h3>{fallback['stats']}</div>",
+                    gr.Radio(choices=fallback['options'], interactive=True),
+                    [[str(game.turn_number), action_choice, fallback['story']]]
                 )
         
         start_button.click(