Update app.py

app.py

@@ -9,6 +9,7 @@ import getpass
 import re
 import random
 import time
+import pandas as pd
 
 # Set up OpenAI API key
 if 'OPENAI_API_KEY' not in os.environ:
@@ -161,7 +162,7 @@ interactions = pxt.create_table(
         'timestamp': pxt.Timestamp,
         'player_stats': pxt.String,
         'random_event': pxt.String,
-        'use_fallback': pxt.Bool,  # Changed from Boolean to Bool
+        'use_fallback': pxt.Bool,
         'fallback_story': pxt.String,
         'fallback_stats': pxt.String,
         'fallback_options': pxt.String
@@ -196,12 +197,17 @@ class RPGGame:
         self.current_session_id = None
         self.turn_number = 0
         self.current_stats = ""
+        # Add game_history to track history directly in memory
+        self.game_history = []
     
     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
         
+        # Reset history for new game
+        self.game_history = []
+        
         # Get initial stats as a string
         initial_stats = initialize_stats(genre)
         self.current_stats = initial_stats
@@ -238,14 +244,37 @@ class RPGGame:
                     (interactions.turn_number == 0)
                 ).collect()
                 
-                return result['story_text'][0], result['stats_update'][0], result['options'][0]
+                story = result['story_text'][0]
+                stats = result['stats_update'][0]
+                options = result['options'][0]
+                
+                # Add to our internal history
+                self.game_history.append(["0", "Game starts", story])
+                
+                return story, stats, options
             except Exception as e:
+                print(f"Error getting initial response: {str(e)}")
                 # If OpenAI fails, use the fallback values
-                return fallback["story"], fallback["stats"], fallback["options"]
+                story = fallback["story"]
+                stats = fallback["stats"]
+                options = fallback["options"]
+                
+                # Still add to history even if using fallback
+                self.game_history.append(["0", "Game starts", story])
+                
+                return story, stats, options
                 
         except Exception as e:
+            print(f"Error inserting initial turn: {str(e)}")
             # If everything fails, return fallback
-            return fallback["story"], fallback["stats"], fallback["options"]
+            story = fallback["story"]
+            stats = fallback["stats"]
+            options = fallback["options"]
+            
+            # Still add to history even if using fallback
+            self.game_history.append(["0", "Game starts", story])
+            
+            return story, stats, options
     
     def process_action(self, action: str) -> tuple[str, str, list[str]]:
         if not self.current_session_id:
@@ -280,8 +309,9 @@ class RPGGame:
                 ]
                 random_event_val = random.choice(events)
             
+            modified_action = action
             if random_event_val:
-                action = f"{action} ({random_event_val})"
+                modified_action = f"{action} ({random_event_val})"
             
             # Create fallback content
             fallback = create_fallback_response(action, self.turn_number)
@@ -292,7 +322,7 @@ class RPGGame:
                 'genre': prev_turn['genre'][0],
                 'initial_scenario': prev_turn['initial_scenario'][0],
                 'turn_number': self.turn_number,
-                'player_input': action,
+                'player_input': modified_action,
                 'timestamp': datetime.now(),
                 'player_stats': self.current_stats,
                 'random_event': random_event_val,
@@ -313,17 +343,44 @@ class RPGGame:
                 ).collect()
                 
                 # Update stats for next turn
-                self.current_stats = result['stats_update'][0]
+                story = result['story_text'][0]
+                stats = result['stats_update'][0]
+                options = result['options'][0]
+                
+                self.current_stats = stats
                 
-                return result['story_text'][0], result['stats_update'][0], result['options'][0]
+                # Add to our internal history
+                self.game_history.append([str(self.turn_number), modified_action, story])
+                
+                return story, stats, options
             except Exception as e:
+                print(f"Error getting turn response: {str(e)}")
                 # If OpenAI fails, use the fallback values
-                return fallback["story"], fallback["stats"], fallback["options"]
+                story = fallback["story"]
+                stats = fallback["stats"]
+                options = fallback["options"]
+                
+                # Add to our internal history even with fallback
+                self.game_history.append([str(self.turn_number), modified_action, story])
+                
+                return story, stats, options
                 
         except Exception as e:
+            print(f"Error processing action: {str(e)}")
             # If everything fails, use fallback
             fallback = create_fallback_response(action, self.turn_number)
-            return fallback["story"], fallback["stats"], fallback["options"]
+            story = fallback["story"]
+            stats = fallback["stats"]
+            options = fallback["options"]
+            
+            # Add to our internal history even with fallback
+            self.game_history.append([str(self.turn_number), action, story])
+            
+            return story, stats, options
+            
+    def get_history(self):
+        """Return the game history from memory instead of querying the database"""
+        return self.game_history
 
 def create_interface():
     game = RPGGame()
@@ -482,12 +539,12 @@ def create_interface():
                 gr.Examples(
                     examples=[
                         ["Admiral Yi", "🧙‍♂️ Fantasy", "You wake up at the edge of a forgotten mystical forest. In the distance, you can see castle spires, and in your mind remains only the clue about ancient magic threatening the kingdom. Suddenly, you see a strange light coming from the forest..."],
-                        ["Trump", "🚀 Sci-Fi", "As the navigator of the starship 'Horizon', you wake up to an emergency alarm during the exploration of an unknown planet. Contact with the captain has been lost, and life support systems are gradually failing. You hear strange footsteps in the quiet ship..."],
+                        ["Ji-Young Kim", "🚀 Sci-Fi", "As the navigator of the starship 'Horizon', you wake up to an emergency alarm during the exploration of an unknown planet. Contact with the captain has been lost, and life support systems are gradually failing. You hear strange footsteps in the quiet ship..."],
                         ["Elon Musk", "🤖 Cyberpunk", "Seoul, 2077. You are the CEO of Neural Link Industries. Your latest brain-computer interface technology has started giving users an unexpected ability - they can communicate with their houseplants. As you prepare for a major investor presentation, your AI assistant reports that test participants are organizing a mysterious 'plant revolution'..."],
                         ["Gordon Ramsay", "🌋 Post-Apocalyptic", "You are the last master chef in New Seoul, running an underground restaurant in the ruins of an old luxury hotel. Your signature dish requires a rare mushroom that only grows in dangerous radioactive zones. While preparing for tonight's secret gathering, your scout returns with ominous news about rival chef gangs in the area..."],
-                        ["Sonic", "👻 Horror", "You came to a secluded cabin in the forest for the weekend at your friend's invitation. On the first night, you are drawn into the forest by a strange light visible through the window. As you try to find your way back, you can't see the cabin, and unfamiliar fog grows thicker. In the distance, you hear someone—no, something calling you..."],
-                        ["Picatsu", "🔍 Mystery", "As a rookie detective, your first case is the mysterious disappearance of the CEO of the city's top tech company. There's no blood in his office, and the only clues are an encrypted note on the desk and his powered-down cutting-edge AI assistant. As you begin your investigation, you hear about a secret project the CEO was working on..."],
-                        ["Dooly", "⚙️ Steampunk", "In New Joseon, filled with steam and gears, you are an innovative airship designer. During a demonstration of your latest invention, a government secret agent approaches with a secret mission for the imperial family in danger. Underground groups are threatening the throne, and your invention is the royal family's only hope..."]
+                        ["Jung-Ho Yoo", "👻 Horror", "You came to a secluded cabin in the forest for the weekend at your friend's invitation. On the first night, you are drawn into the forest by a strange light visible through the window. As you try to find your way back, you can't see the cabin, and unfamiliar fog grows thicker. In the distance, you hear someone—no, something calling you..."],
+                        ["Detective Park", "🔍 Mystery", "As a rookie detective, your first case is the mysterious disappearance of the CEO of the city's top tech company. There's no blood in his office, and the only clues are an encrypted note on the desk and his powered-down cutting-edge AI assistant. As you begin your investigation, you hear about a secret project the CEO was working on..."],
+                        ["Min-Su Lee", "⚙️ Steampunk", "In New Joseon, filled with steam and gears, you are an innovative airship designer. During a demonstration of your latest invention, a government secret agent approaches with a secret mission for the imperial family in danger. Underground groups are threatening the throne, and your invention is the royal family's only hope..."]
                     ],
                     inputs=[player_name, genre, scenario]
                 )
@@ -513,30 +570,15 @@ def create_interface():
             try:
                 initial_story, initial_stats, initial_options = game.start_game(name, genre_choice, scenario_text)
                 
-                # 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]]
+                # Get history from our in-memory tracking
+                history_data = game.get_history()
                 
                 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:
+                print(f"Error in start_new_game: {str(e)}")
                 # Handle any other unexpected errors
                 fallback = create_fallback_response("Game starts", 0)
                 return (
@@ -558,31 +600,15 @@ def create_interface():
                     
                 story, stats, options = game.process_action(action_choice)
                 
-                # 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]]
+                # Get history from our in-memory tracking
+                history_data = game.get_history()
                 
                 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:
+                print(f"Error in process_player_action: {str(e)}")
                 # Handle any other unexpected errors
                 fallback = create_fallback_response(action_choice, 1)
                 return (