Update app.py

app.py

@@ -8,6 +8,7 @@ import os
 import getpass
 import re
 import random
+import time
 
 # Set up OpenAI API key
 if 'OPENAI_API_KEY' not in os.environ:
@@ -17,55 +18,39 @@ if 'OPENAI_API_KEY' not in os.environ:
 pxt.drop_dir('ai_rpg', force=True)
 pxt.create_dir('ai_rpg')
 
-# 일반 함수로 변경 (UDF가 아님)
+# Regular function (not UDF)
 def initialize_stats(genre: str) -> str:
     """Initialize player stats based on the selected genre"""
     base_stats = {
-        "🧙‍♂️ Fantasy": "체력: 100, 마나: 80, 힘: 7, 지능: 8, 민첩: 6, 소지금: 50골드",
-        "🚀 Sci-Fi": "체력: 100, 에너지: 90, 기술력: 8, 지능: 9, 민첩: 6, 크레딧: 500",
-        "👻 Horror": "체력: 80, 정신력: 100, 힘: 6, 지능: 7, 민첩: 8, 소지품: 손전등, 기본 약품",
-        "🔍 Mystery": "체력: 90, 집중력: 100, 관찰력: 9, 지능: 8, 카리스마: 7, 단서: 0",
-        "🌋 Post-Apocalyptic": "체력: 95, 방사능 저항: 75, 힘: 8, 생존력: 9, 물자: 제한됨",
-        "🤖 Cyberpunk": "체력: 90, 사이버웨어: 85%, 해킹: 8, 거리 신용도: 6, 엣지: 7, 누엔: 1000",
-        "⚙️ Steampunk": "체력: 95, 증기력: 85, 기계공학: 8, 예술성: 7, 사교성: 6, 실링: 200"
+        "🧙‍♂️ Fantasy": "Health: 100, Mana: 80, Strength: 7, Intelligence: 8, Agility: 6, Gold: 50",
+        "🚀 Sci-Fi": "Health: 100, Energy: 90, Tech: 8, Intelligence: 9, Agility: 6, Credits: 500",
+        "👻 Horror": "Health: 80, Sanity: 100, Strength: 6, Intelligence: 7, Agility: 8, Items: Flashlight, First Aid",
+        "🔍 Mystery": "Health: 90, Focus: 100, Observation: 9, Intelligence: 8, Charisma: 7, Clues: 0",
+        "🌋 Post-Apocalyptic": "Health: 95, Radiation Resistance: 75, Strength: 8, Survival: 9, Supplies: Limited",
+        "🤖 Cyberpunk": "Health: 90, Cyberware: 85%, Hacking: 8, Street Cred: 6, Edge: 7, Nuyen: 1000",
+        "⚙️ Steampunk": "Health: 95, Steam Power: 85, Engineering: 8, Artistry: 7, Social: 6, Shillings: 200"
     }
     
     if genre in base_stats:
         return base_stats[genre]
     else:
         # Default stats if genre not found
-        return "체력: 100, 에너지: 100, 힘: 7, 지능: 7, 민첩: 7, 소지금: 100"
-
-@pxt.udf
-def generate_random_event(turn_number: int) -> str:
-    """Generate a random event based on turn number"""
-    if turn_number % 3 == 0 and turn_number > 0:  # Every 3rd turn
-        events = [
-            "갑자기 부근에서 이상한 소리가 들립니다",
-            "낯선 여행자가 당신을 바라보고 있습니다",
-            "지면이 미세하게 진동하기 시작합니다",
-            "주머니에서 무언가가 빛납니다",
-            "멀리서 무언가가 당신을 향해 다가오고 있습니다",
-            "갑자기 날씨가 변하기 시작합니다",
-            "주변에 숨겨진 통로를 발견합니다"
-        ]
-        return random.choice(events)
-    return ""
+        return "Health: 100, Energy: 100, Strength: 7, Intelligence: 7, Agility: 7, Money: 100"
 
 @pxt.udf
 def generate_messages(genre: str, player_name: str, initial_scenario: str, player_input: str, turn_number: int, stats: str) -> list[dict]:
     return [
         {
             'role': 'system',
-            'content': f"""반드시 한국어(한글)로 작성하라. You are the game master for a {genre} RPG. The player's name is {player_name}.
+            'content': f"""You are the game master for a {genre} RPG. The player's name is {player_name}.
             
-            관리해야 할 플레이어 스탯: {stats}
+            Player stats to manage: {stats}
             
-            당신은 플레이어의 선택에 따라 스토리를 생생하게 전개하는 게임 마스터입니다. 
-            상세한 설명과 감각적인 묘사를 통해 플레이어가 게임 속 세계에 몰입할 수 있도록 하세요.
+            You are a game master who vividly develops stories based on the player's choices.
+            Use detailed descriptions and sensory details to help the player immerse themselves in the game world.
             
-            플레이어의 선택에 따라 스탯이 변하는 경우 이를 스토리에 반영하세요. 
-            위험한 상황, 도전, 보상, 우연한 만남이 포함된 흥미로운 스토리를 만드세요.
+            When player stats change based on their choices, reflect this in the story.
+            Create interesting stories that include dangerous situations, challenges, rewards, and chance encounters.
             
             Provide your response in three clearly separated sections using exactly this format:
 
@@ -89,6 +74,30 @@ 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"""
@@ -111,7 +120,7 @@ def get_stats_update(response: str) -> str:
     if len(parts) > 1:
         stats_part = parts[1].split("OPTIONS:")[0].strip()
         return stats_part
-    return "스탯 변화 없음"
+    return "No stat changes"
 
 @pxt.udf
 def get_options(response: str) -> list[str]:
@@ -122,7 +131,7 @@ def get_options(response: str) -> list[str]:
         options = re.findall(r'\d+\.\s*(.*?)(?=\d+\.|$)', options_text, re.DOTALL)
         options = [opt.strip() for opt in options if opt.strip()]
         while len(options) < 4:
-            options.append("다른 행동 시도...")
+            options.append("Try something else...")
         return options[:4]
     
     parts = response.split("OPTIONS:")
@@ -130,10 +139,10 @@ def get_options(response: str) -> list[str]:
         options = re.findall(r'\d+\.\s*(.*?)(?=\d+\.|$)', parts[1], re.DOTALL)
         options = [opt.strip() for opt in options if opt.strip()]
         while len(options) < 4:
-            options.append("다른 행동 시도...")
+            options.append("Try something else...")
         return options[:4]
     
-    return ["계속하기...", "다른 행동 취하기", "뭔가 새로운 시도하기", "주변 탐색하기"]
+    return ["Continue...", "Take a different action", "Try something new", "Explore surroundings"]
 
 # Create a single table for all game data
 interactions = pxt.create_table(
@@ -161,9 +170,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
 interactions.add_computed_column(ai_response=openai.chat_completions(
     messages=interactions.messages,
-    model='gpt-4.1-mini',
+    model='gpt-3.5-turbo',  # Changed to a more widely available model
     max_tokens=800,
     temperature=0.8
 ))
@@ -184,93 +194,125 @@ class RPGGame:
         self.current_session_id = session_id
         self.turn_number = 0
         
-        # 함수를 직접 호출하여 결과를 저장
+        # Get initial stats as a string
         initial_stats = initialize_stats(genre)
         self.current_stats = initial_stats
         
-        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(),
-            'player_stats': initial_stats,  # 문자열 결과 저장
-            'random_event': ""
-        }])
-        
-        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]
+        try:
+            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(),
+                'player_stats': initial_stats,  # Store string result
+                'random_event': ""
+            }])
+            
+            # 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)
+        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)
     
     def process_action(self, action: str) -> tuple[str, str, list[str]]:
         if not self.current_session_id:
-            return "게임 세션이 활성화되지 않았습니다. 새 게임을 시작하세요.", "스탯 없음", []
+            return "No active game session. Please start a new game.", "No stats", []
         
         self.turn_number += 1
         
-        prev_turn = interactions.select(
-            interactions.player_name,
-            interactions.genre,
-            interactions.initial_scenario,
-            interactions.player_stats
-        ).where(
-            (interactions.session_id == self.current_session_id) &
-            (interactions.turn_number == self.turn_number - 1)
-        ).collect()
-        
-        self.current_stats = prev_turn['player_stats'][0]
-        
-        # 일반 함수로 변환했으므로 그냥 호출해서 사용
-        random_event_val = ""
-        if self.turn_number % 3 == 0 and self.turn_number > 0:
-            events = [
-                "갑자기 부근에서 이상한 소리가 들립니다",
-                "낯선 여행자가 당신을 바라보고 있습니다",
-                "지면이 미세하게 진동하기 시작합니다",
-                "주머니에서 무언가가 빛납니다",
-                "멀리서 무언가가 당신을 향해 다가오고 있습니다",
-                "갑자기 날씨가 변하기 시작합니다",
-                "주변에 숨겨진 통로를 발견합니다"
-            ]
-            random_event_val = random.choice(events)
-        
-        if random_event_val:
-            action = f"{action} ({random_event_val})"
-        
-        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(),
-            'player_stats': self.current_stats,
-            'random_event': random_event_val
-        }])
-        
-        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]
+        try:
+            prev_turn = interactions.select(
+                interactions.player_name,
+                interactions.genre,
+                interactions.initial_scenario,
+                interactions.player_stats
+            ).where(
+                (interactions.session_id == self.current_session_id) &
+                (interactions.turn_number == self.turn_number - 1)
+            ).collect()
+            
+            self.current_stats = prev_turn['player_stats'][0]
+            
+            # Generate random event directly
+            random_event_val = ""
+            if self.turn_number % 3 == 0 and self.turn_number > 0:
+                events = [
+                    "Suddenly, you hear a strange sound nearby",
+                    "A mysterious traveler is watching you",
+                    "The ground begins to vibrate slightly",
+                    "Something in your pocket starts to glow",
+                    "Something is approaching you from the distance",
+                    "The weather suddenly begins to change",
+                    "You discover a hidden passage nearby"
+                ]
+                random_event_val = random.choice(events)
+            
+            if random_event_val:
+                action = f"{action} ({random_event_val})"
+            
+            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(),
+                'player_stats': self.current_stats,
+                'random_event': random_event_val
+            }])
+            
+            # 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)
+        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)
 
 def create_interface():
     game = RPGGame()
@@ -299,7 +341,7 @@ def create_interface():
         border-radius: 10px;
         box-shadow: 0 2px 10px rgba(0,0,0,0.1);
         margin-bottom: 20px;
-        font-family: 'Noto Sans KR', sans-serif;
+        font-family: 'Roboto', sans-serif;
     }
     
     .stats-container {
@@ -349,34 +391,34 @@ def create_interface():
         gr.HTML(
             """
             <div class="title-container">
-                <h1 style="margin-bottom: 0.5em; font-size: 2.5em;">🎲 AI RPG 어드벤처</h1>
-                <p style="font-size: 1.2em;">Pixeltable과 OpenAI로 구현된 몰입형 롤플레잉 게임 경험!</p>
+                <h1 style="margin-bottom: 0.5em; font-size: 2.5em;">🎲 AI RPG Adventure</h1>
+                <p style="font-size: 1.2em;">An immersive roleplaying experience powered by Pixeltable and OpenAI!</p>
             </div>
             """
         )
         
         with gr.Row():
             with gr.Column(scale=1):
-                with gr.Accordion("🎯 이 앱은 무엇인가요?", open=False):
+                with gr.Accordion("🎯 What is this app?", open=False):
                     gr.HTML(
                         """
                         <div style="padding: 15px;">
-                            <h3>AI RPG 어드벤처는 다음 기능을 보여줍니다:</h3>
+                            <h3>AI RPG Adventure showcases:</h3>
                             <ul style="list-style-type: none; padding-left: 5px;">
-                                <li>🎮 <b>동적 스토리텔링:</b> AI가 생성하는 몰입형 이야기 경험</li>
-                                <li>🔄 <b>게임 상태 관리:</b> Pixeltable로 게임 상태와 기록 추적</li>
-                                <li>💭 <b>컨텍스트 기반 선택지:</b> 플레이어 행동에 따른 맞춤형 옵션</li>
-                                <li>🤖 <b>AI 스토리텔링:</b> 생생한 내러티브 생성</li>
-                                <li>📊 <b>캐릭터 상태 추적:</b> 게임 진행에 따른 스탯 변화</li>
+                                <li>🎮 <b>Dynamic Storytelling:</b> AI-generated immersive stories</li>
+                                <li>🔄 <b>Game State Management:</b> Tracking game state with Pixeltable</li>
+                                <li>💭 <b>Contextual Choices:</b> Custom options based on player actions</li>
+                                <li>🤖 <b>AI Narratives:</b> Vivid storytelling</li>
+                                <li>📊 <b>Character Status Tracking:</b> Stat changes as you play</li>
                             </ul>
                         </div>
                         """
                     )
                 
-                with gr.Accordion("🎨 캐릭터 생성", open=True):
+                with gr.Accordion("🎨 Create Character", open=True):
                     player_name = gr.Textbox(
-                        label="👤 캐릭터 이름",
-                        placeholder="당신의 캐릭터 이름을 입력하세요...",
+                        label="👤 Character Name",
+                        placeholder="Enter your character's name...",
                         container=False
                     )
                     genre = gr.Dropdown(
@@ -389,60 +431,60 @@ def create_interface():
                             "🤖 Cyberpunk",
                             "⚙️ Steampunk"
                         ],
-                        label="🎭 장르 선택",
+                        label="🎭 Choose Genre",
                         container=False,
                         value="🧙‍♂️ Fantasy"
                     )
                     scenario = gr.Textbox(
-                        label="📖 시작 시나리오",
+                        label="📖 Starting Scenario",
                         lines=3,
-                        placeholder="초기 설정과 상황을 설명하세요...",
+                        placeholder="Describe the initial setting and situation...",
                         container=False
                     )
-                    start_button = gr.Button("🎮 모험 시작!", variant="primary")
+                    start_button = gr.Button("🎮 Begin Adventure!", variant="primary")
             
             with gr.Column(scale=2):
                 story_display = gr.Markdown(
-                    label="📜 스토리",
-                    value="<div class='story-container'>모험을 시작하려면 캐릭터를 생성하고 '모험 시작!' 버튼을 클릭하세요.</div>",
+                    label="📜 Story",
+                    value="<div class='story-container'>Create a character and click 'Begin Adventure!' to start your journey.</div>",
                     show_label=False
                 )
                 
                 stats_display = gr.Markdown(
-                    label="📊 캐릭터 스탯",
-                    value="<div class='stats-container'>모험을 시작하면 캐릭터 스탯이 이곳에 표시됩니다.</div>",
+                    label="📊 Character Stats",
+                    value="<div class='stats-container'>Character stats will appear here when you start your adventure.</div>",
                     show_label=False
                 )
                 
-                gr.HTML("<div class='options-container'><h3>🎯 다음 행동 선택</h3></div>")
+                gr.HTML("<div class='options-container'><h3>🎯 Choose Your Next Action</h3></div>")
                 
                 action_input = gr.Radio(
                     choices=[],
                     label="",
                     interactive=True
                 )
-                submit_action = gr.Button("⚡ 행동 실행", variant="primary")
+                submit_action = gr.Button("⚡ Take Action", variant="primary")
         
         with gr.Row():
             with gr.Column():
-                gr.HTML("<div class='history-container'><h3>💫 어드벤처 예시</h3></div>")
+                gr.HTML("<div class='history-container'><h3>💫 Adventure Examples</h3></div>")
                 gr.Examples(
                     examples=[
-                        ["이순신", "🧙‍♂️ Fantasy", "당신은 잊혀진 신비한 숲의 가장자리에서 눈을 뜹니다. 멀리서 성의 첨탑이 보이고, 당신의 머리속에는 왕국을 위협하는 고대 마법에 관한 단서만이 남아있습니다. 갑자기 숲에서 이상한 빛이 보입니다..."],
-                        ["김지영", "🚀 Sci-Fi", "우주선 '호라이즌'의 항해사로서, 당신은 미지의 행성 탐사 중 비상 알람에 깨어납니다. 선장과 연락이 두절되었고, 생명 유지 시스템이 점차 실패하고 있습니다. 조용한 선내에서 이상한 발걸음 소리가 들립니다..."],
-                        ["일론 머스크", "🤖 Cyberpunk", "2077년 서울, 당신은 뉴럴링크 인더스트리의 CEO입니다. 당신의 최신 뇌-컴퓨터 인터페이스 기술이 사용자들에게 예상치 못한 능력을 부여하기 시작했습니다 - 그들의 집안 식물과 교감할 수 있게 된 것입니다. 주요 투자자 프레젠테이션을 준비하는 동안, AI 비서가 테스트 참가자들이 불가사의한 '식물 혁명'을 조직하고 있다는 보고를 전합니다..."],
-                        ["고든 램지", "🌋 Post-Apocalyptic", "당신은 뉴 서울의 마지막 마스터 셰프로, 옛 럭셔리 호텔 폐허에서 지하 레스토랑을 운영하고 있습니다. 당신의 시그니처 요리는 위험한 방사능 구역에서만 자라는 희귀 버섯이 필요합니다. 오늘 밤의 비밀 모임을 준비하던 중, 정찰병이 주변 지역의 경쟁 요리사 갱단에 관한 불길한 소식을 가지고 돌아옵니다..."],
-                        ["유정호", "👻 Horror", "당신은 친구의 초대로 삼림 속 외딴 별장에 주말을 보내러 왔습니다. 첫날 밤, 창밖으로 보이는 기이한 빛에 이끌려 숲으로 들어가게 됩니다. 돌아오는 길을 찾으려 하지만, 별장이 보이지 않고 낯선 안개가 점점 짙어집니다. 멀리서 누군가—아니, 무언가가 당신을 부르는 소리가 들립니다..."],
-                        ["박지훈", "🔍 Mystery", "신임 형사로서 당신의 첫 사건은 도시 최고의 기술 기업 CEO의 의문의 실종입니다. 그의 사무실에는 혈흔이 없고, 유일한 단서는 책상 위에 놓인 암호화된 메모와 꺼져있는 그의 최첨단 AI 비서뿐입니다. 조사를 시작하자마자, 당신은 CEO가 마지막으로 작업하던 비밀 프로젝트에 관한 이야기를 듣게 됩니다..."],
-                        ["이민수", "⚙️ Steampunk", "증기와 기어로 가득한 뉴 조선에서, 당신은 혁신적인 비행선 설계자입니다. 당신의 최신 발명품 시연 중, 정부의 비밀 요원이 접근해 위험에 처한 황실 가족을 위한 비밀 임무를 제안합니다. 지하 단체들이 왕좌를 위협하고 있으며, 당신의 발명품이 왕가의 유일한 희망이라고 합니다..."]
+                        ["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..."],
+                        ["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..."],
+                        ["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]
                 )
             
             with gr.Column():
                 history_df = gr.Dataframe(
-                    headers=["📅 턴", "🎯 플레이어 행동", "💬 게임 반응"],
-                    label="📚 모험 역사",
+                    headers=["📅 Turn", "🎯 Player Action", "💬 Game Response"],
+                    label="📚 Adventure History",
                     wrap=True,
                     row_count=5,
                     col_count=(3, "fixed")
@@ -451,8 +493,8 @@ def create_interface():
         def start_new_game(name, genre_choice, scenario_text):
             if not name or not genre_choice or not scenario_text:
                 return (
-                    "<div class='story-container'>모든 필드를 입력한 후 시작하세요.</div>",
-                    "<div class='stats-container'>스탯 정보 없음</div>",
+                    "<div class='story-container'>Please fill in all fields before starting.</div>",
+                    "<div class='stats-container'>No stat information</div>",
                     [],
                     []
                 )
@@ -476,13 +518,13 @@ def create_interface():
                 ]
                 
                 story_html = f"<div class='story-container'>{initial_story}</div>"
-                stats_html = f"<div class='stats-container'><h3>📊 캐릭터 상태</h3>{initial_stats}</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:
                 return (
-                    f"<div class='story-container'>게임 시작 오류: {str(e)}</div>",
-                    "<div class='stats-container'>스탯 정보 없음</div>",
+                    f"<div class='story-container'>Game start error: {str(e)}</div>",
+                    "<div class='stats-container'>No stat information</div>",
                     [],
                     []
                 )
@@ -491,8 +533,8 @@ def create_interface():
             try:
                 if not action_choice:
                     return (
-                        "<div class='story-container'>계속하려면 행동을 선택하세요.</div>",
-                        "<div class='stats-container'>스탯 정보 없음</div>",
+                        "<div class='story-container'>Please select an action to continue.</div>",
+                        "<div class='stats-container'>No stat information</div>",
                         [],
                         []
                     )
@@ -515,13 +557,13 @@ def create_interface():
                 ]
                 
                 story_html = f"<div class='story-container'>{story}</div>"
-                stats_html = f"<div class='stats-container'><h3>📊 캐릭터 상태</h3>{stats}</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:
                 return (
-                    f"<div class='story-container'>오류: {str(e)}</div>",
-                    "<div class='stats-container'>스탯 정보 없음</div>",
+                    f"<div class='story-container'>Error: {str(e)}</div>",
+                    "<div class='stats-container'>No stat information</div>",
                     [],
                     []
                 )
@@ -540,8 +582,8 @@ def create_interface():
         
         gr.HTML("""
         <div style="text-align: center; margin-top: 30px; padding: 20px; background: #f5f5f5; border-radius: 10px;">
-            <h3>🌟 AI RPG 어드벤처 - Pixeltable로 제작된 몰입형 롤플레잉 경험</h3>
-            <p>자신만의 캐릭터를 만들고, 선택한 장르의 세계에서 모험을 즐기세요. 당신의 선택이 스토리를 형성합니다!</p>
+            <h3>🌟 AI RPG Adventure - An Immersive Roleplaying Experience Powered by Pixeltable</h3>
+            <p>Create your own character and embark on an adventure in a world of your chosen genre. Your choices shape the story!</p>
         </div>
         """)