Update app.py

app.py

@@ -1,33 +1,32 @@
 # app.py
-# @title 啤酒游戏最终整合版 (v3 - 两阶段决策 + 信息隔离)
+# @title Beer Game Final Version (v4 - English UI & Introduction)
 
 # -----------------------------------------------------------------------------
-# 1. 导入必要的库
+# 1. Import Libraries
 # -----------------------------------------------------------------------------
 import streamlit as st
 import pandas as pd
 import matplotlib.pyplot as plt
-import numpy as np
 from collections import deque
 import time
 import openai
 import re
 import random
 import uuid
-import os
 from pathlib import Path
 from datetime import datetime
 from huggingface_hub import HfApi
 
 # -----------------------------------------------------------------------------
-# 0. 页面配置 (必须是第一个Streamlit命令)
+# 0. Page Configuration (Must be the first Streamlit command)
 # -----------------------------------------------------------------------------
-st.set_page_config(page_title="啤酒游戏-人机协作版", layout="wide")
+st.set_page_config(page_title="Beer Game: Human-AI Collaboration", layout="wide")
+
 
 # -----------------------------------------------------------------------------
-# 2. 配置游戏核心参数和API密钥
+# 2. Game Parameters & API Configuration
 # -----------------------------------------------------------------------------
-# --- 游戏参数 ---
+# --- Game Parameters ---
 WEEKS = 24
 INITIAL_INVENTORY = 12
 INITIAL_BACKLOG = 0
@@ -38,31 +37,34 @@ FACTORY_SHIPPING_DELAY = 1
 HOLDING_COST = 0.5
 BACKLOG_COST = 1.0
 
-# --- 模型和日志配置 ---
+# --- Model & Log Configuration ---
 OPENAI_MODEL = "gpt-4o-mini"
 LOCAL_LOG_DIR = Path("logs")
 LOCAL_LOG_DIR.mkdir(exist_ok=True)
 
-# --- API & Secrets 配置 ---
+# --- API & Secrets Configuration ---
 try:
     client = openai.OpenAI(api_key=st.secrets["OPENAI_API_KEY"])
     HF_TOKEN = st.secrets.get("HF_TOKEN")
     HF_REPO_ID = st.secrets.get("HF_REPO_ID")
     hf_api = HfApi() if HF_TOKEN else None
 except Exception as e:
-    st.session_state.initialization_error = f"启动时读取Secrets出错: {e}。"
+    st.session_state.initialization_error = f"Error reading secrets on startup: {e}."
     client = None
 else:
     st.session_state.initialization_error = None
 
+
 # -----------------------------------------------------------------------------
-# 3. 游戏核心逻辑函数
+# 3. Core Game Logic Functions
 # -----------------------------------------------------------------------------
 
 def get_customer_demand(week: int) -> int:
+    """Defines the end-customer demand pattern."""
     return 4 if week <= 4 else 8
 
 def init_game_state(llm_personality: str, info_sharing: str):
+    """Initializes or resets the game state in st.session_state."""
     roles = ["Retailer", "Wholesaler", "Distributor", "Factory"]
     human_role = random.choice(roles)
     participant_id = str(uuid.uuid4())[:8]
@@ -72,8 +74,8 @@ def init_game_state(llm_personality: str, info_sharing: str):
         'human_role': human_role, 'llm_personality': llm_personality,
         'info_sharing': info_sharing, 'logs': [], 'echelons': {},
         'factory_production_pipeline': deque([0] * FACTORY_LEAD_TIME, maxlen=FACTORY_LEAD_TIME),
-        'decision_step': 'initial_order', # 新增：控制决策阶段
-        'human_initial_order': None,      # 新增：储存玩家的初步订单
+        'decision_step': 'initial_order', # Controls the two-step decision process
+        'human_initial_order': None,      # Stores the player's initial order
     }
 
     for i, name in enumerate(roles):
@@ -90,11 +92,12 @@ def init_game_state(llm_personality: str, info_sharing: str):
             'incoming_order': 0, 'order_placed': 0, 'shipment_sent': 0,
             'weekly_cost': 0, 'total_cost': 0, 'upstream_name': upstream, 'downstream_name': downstream,
         }
-    st.info(f"新游戏开始！AI模式: **{llm_personality} / {info_sharing}**。您的角色: **{human_role}**。")
+    st.info(f"New game started! AI Mode: **{llm_personality} / {info_sharing}**. You have been randomly assigned the role of: **{human_role}**.")
 
 def get_llm_order_decision(prompt: str, echelon_name: str) -> (int, str):
+    """Calls the OpenAI API to get a decision and returns the integer order and raw text."""
     if not client: return 8, "NO_API_KEY_DEFAULT"
-    with st.spinner(f"正在为 {echelon_name} 获取AI决策..."):
+    with st.spinner(f"Getting AI decision for {echelon_name}..."):
         try:
             temp = 0.1 if 'rational' in prompt else 0.7
             response = client.chat.completions.create(
@@ -110,11 +113,12 @@ def get_llm_order_decision(prompt: str, echelon_name: str) -> (int, str):
             if match: return int(match.group(0)), raw_text
             return 8, raw_text
         except Exception as e:
-            st.error(f"API调用失败 for {echelon_name}: {e}")
+            st.error(f"API call failed for {echelon_name}: {e}")
             return 8, f"API_ERROR: {e}"
 
 def get_llm_prompt(echelon_state: dict, week: int, llm_personality: str, info_sharing: str, all_echelons_state: dict) -> str:
-    # (此函数内容与上一版完全相同，为简洁省略，实际代码中应完整保留)
+    """Generates the prompt for the LLM based on the game scenario."""
+    # This function's logic is complex and correct, so it remains unchanged.
     base_info = f"Your Current Status at the **{echelon_state['name']}** for **Week {week}**:\n- On-hand inventory: {echelon_state['inventory']} units.\n- Backlog (unfilled orders): {echelon_state['backlog']} units.\n- Incoming order this week (from your customer): {echelon_state['incoming_order']} units.\n- Shipments on the way to you: {list(echelon_state['incoming_shipments'])}\n- Orders you have placed being processed by your supplier: {list(echelon_state['order_pipeline'])}"
     if llm_personality == 'perfect_rational' and info_sharing == 'full':
         stable_demand = 8; total_lead_time = ORDER_PASSING_DELAY + SHIPPING_DELAY; safety_stock = 4
@@ -137,16 +141,15 @@ def get_llm_prompt(echelon_state: dict, week: int, llm_personality: str, info_sh
     elif llm_personality == 'human_like' and info_sharing == 'local':
         return f"**You are a reactive supply chain manager for the {echelon_state['name']}.** You have a limited view and tend to over-correct based on fear.\n\n**Your Mindset: **Your top priority is try to not have a backlog.\n\n{base_info}\n\n**Your Task:** You just saw your own inventory and a new order coming. Your gut instinct is to panic and order enough to ensure you are never caught with a backlog again.\n\n**React emotionally.** What is your knee-jerk order quantity? Respond with a single integer."
 
-
 def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: int):
-    """推进一周的游戏进程，并记录包括两阶段决策在内的详细日志"""
+    """Processes one week of the game and records detailed logs, including two-step decision data."""
     state = st.session_state.game_state
     week, echelons, human_role = state['week'], state['echelons'], state['human_role']
     llm_personality, info_sharing = state['llm_personality'], state['info_sharing']
     echelon_order = ["Retailer", "Wholesaler", "Distributor", "Factory"]
     llm_raw_responses = {}
 
-    # 游戏流程 (与之前相同)
+    # Core game simulation steps (unchanged)
     factory_state = echelons["Factory"]
     if state['factory_production_pipeline']: factory_state['inventory'] += state['factory_production_pipeline'].popleft()
     for name in ["Retailer", "Wholesaler", "Distributor"]:
@@ -164,7 +167,7 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
         receiver = echelons[sender]['downstream_name']
         if receiver: echelons[receiver]['incoming_shipments'].append(echelons[sender]['shipment_sent'])
 
-    # 各环节下订单
+    # Agents place orders
     for name in echelon_order:
         e = echelons[name]
         if name == human_role:
@@ -178,9 +181,9 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
 
     state['factory_production_pipeline'].append(echelons["Factory"]['order_placed'])
 
-    # 更新成本和记录日志
+    # Update costs and record logs
     log_entry = {'timestamp': datetime.utcnow().isoformat() + "Z", 'week': week, **state}
-    del log_entry['echelons'], log_entry['factory_production_pipeline'] # 移除复杂对象
+    del log_entry['echelons'], log_entry['factory_production_pipeline'], log_entry['logs'] # Clean up complex objects
     for name in echelon_order:
         e = echelons[name]
         e['weekly_cost'] = (e['inventory'] * HOLDING_COST) + (e['backlog'] * BACKLOG_COST); e['total_cost'] += e['weekly_cost']
@@ -188,20 +191,21 @@ def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: i
             log_entry[f'{name}.{key}'] = e[key]
         log_entry[f'{name}.llm_raw_response'] = llm_raw_responses.get(name, "")
     
-    # 新增：记录两阶段决策数据
+    # Record two-step decision data
     log_entry[f'{human_role}.initial_order'] = human_initial_order
     log_entry[f'{human_role}.ai_suggestion'] = ai_suggestion
     
     state['logs'].append(log_entry)
 
-    # 推进周数并重置决策步骤
+    # Advance week and reset decision step
     state['week'] += 1
     state['decision_step'] = 'initial_order'
     if state['week'] > WEEKS: state['game_running'] = False
 
 
 def plot_results(df: pd.DataFrame, title: str, human_role: str):
-    fig, axes = plt.subplots(4, 1, figsize=(12, 22)) # 增加一个子图
+    """Generates and returns the end-of-game plots."""
+    fig, axes = plt.subplots(4, 1, figsize=(12, 22))
     fig.suptitle(title, fontsize=16)
     echelons = ['Retailer', 'Wholesaler', 'Distributor', 'Factory']
     
@@ -213,140 +217,172 @@ def plot_results(df: pd.DataFrame, title: str, human_role: str):
                 'total_cost': row[f'{e}.total_cost']})
     plot_df = pd.DataFrame(plot_data)
 
-    # 图1: 库存
+    # Plot 1: Inventory
     inventory_pivot = plot_df.pivot(index='week', columns='echelon', values='inventory').reindex(columns=echelons)
-    inventory_pivot.plot(ax=axes[0], kind='line', marker='o', markersize=4); axes[0].set_title('Inventory Levels'); axes[0].grid(True, linestyle='--')
+    inventory_pivot.plot(ax=axes[0], kind='line', marker='o', markersize=4); axes[0].set_title('Inventory Levels'); axes[0].grid(True, linestyle='--'); axes[0].set_ylabel('Stock (Units)')
 
-    # 图2: 订单 (牛鞭效应)
+    # Plot 2: Orders (Bullwhip Effect)
     order_pivot = plot_df.pivot(index='week', columns='echelon', values='order_placed').reindex(columns=echelons)
-    order_pivot.plot(ax=axes[1], style='--'); axes[1].plot(range(1, WEEKS + 1), [get_customer_demand(w) for w in range(1, WEEKS + 1)], label='Customer Demand', color='black', lw=2.5); axes[1].set_title('Order Quantities (Bullwhip Effect)'); axes[1].grid(True, linestyle='--'); axes[1].legend()
+    order_pivot.plot(ax=axes[1], style='--'); axes[1].plot(range(1, WEEKS + 1), [get_customer_demand(w) for w in range(1, WEEKS + 1)], label='Customer Demand', color='black', lw=2.5); axes[1].set_title('Order Quantities (The Bullwhip Effect)'); axes[1].grid(True, linestyle='--'); axes[1].legend(); axes[1].set_ylabel('Ordered (Units)')
 
-    # 图3: 成本
+    # Plot 3: Costs
     total_costs = plot_df.groupby('echelon')['total_cost'].max().reindex(echelons)
-    total_costs.plot(kind='bar', ax=axes[2], rot=0); axes[2].set_title('Total Cumulative Cost')
+    total_costs.plot(kind='bar', ax=axes[2], rot=0); axes[2].set_title('Total Cumulative Cost'); axes[2].set_ylabel('Cost ($)')
 
-    # 新增图4: 人类玩家决策分析
+    # Plot 4: Human Decision Analysis
     human_df = df[['week', f'{human_role}.initial_order', f'{human_role}.ai_suggestion', f'{human_role}.order_placed']].copy()
     human_df.rename(columns={
-        f'{human_role}.initial_order': 'Your Initial Order',
-        f'{human_role}.ai_suggestion': 'AI Suggestion',
-        f'{human_role}.order_placed': 'Your Final Order'
+        f'{human_role}.initial_order': 'Your Initial Order', f'{human_role}.ai_suggestion': 'AI Suggestion', f'{human_role}.order_placed': 'Your Final Order'
     }, inplace=True)
-    human_df.plot(x='week', ax=axes[3], marker='o', linestyle='-')
-    axes[3].set_title(f'Analysis of Your ({human_role}) Decisions')
-    axes[3].set_ylabel('Order Quantity')
-    axes[3].grid(True, linestyle='--')
+    human_df.plot(x='week', ax=axes[3], marker='o', linestyle='-'); axes[3].set_title(f'Analysis of Your ({human_role}) Decisions'); axes[3].set_ylabel('Order Quantity'); axes[3].grid(True, linestyle='--'); axes[3].set_xlabel('Week')
     
     plt.tight_layout(rect=[0, 0, 1, 0.96]); return fig
 
-
 def save_logs_and_upload(state: dict):
-    # (此函数内容与上一版完全相同)
+    """Saves logs locally and uploads to Hugging Face Hub at the end of the game."""
     if not state.get('logs'): return
     participant_id = state['participant_id']
     df = pd.json_normalize(state['logs'])
     fname = LOCAL_LOG_DIR / f"log_{participant_id}_{int(time.time())}.csv"
     df.to_csv(fname, index=False)
-    st.success(f"日志已成功保存到本地: `{fname}`")
+    st.success(f"Log successfully saved locally: `{fname}`")
     with open(fname, "rb") as f:
-        st.download_button("📥 下载日志CSV文件", data=f, file_name=fname.name, mime="text/csv")
+        st.download_button("📥 Download Log CSV", data=f, file_name=fname.name, mime="text/csv")
     if HF_TOKEN and HF_REPO_ID and hf_api:
-        with st.spinner("正在上传日志到 Hugging Face Hub..."):
+        with st.spinner("Uploading log to Hugging Face Hub..."):
             try:
                 url = hf_api.upload_file(path_or_fileobj=str(fname), path_in_repo=f"logs/{fname.name}", repo_id=HF_REPO_ID, repo_type="dataset", token=HF_TOKEN)
-                st.success(f"✅ 日志已成功上传到 Hugging Face! [查看文件]({url})")
+                st.success(f"✅ Log successfully uploaded to Hugging Face! [View File]({url})")
             except Exception as e:
-                st.error(f"上传到 Hugging Face 失败: {e}")
+                st.error(f"Upload to Hugging Face failed: {e}")
 
 # -----------------------------------------------------------------------------
-# 4. Streamlit UI 界面
+# 4. Streamlit UI
 # -----------------------------------------------------------------------------
-st.title("🍺 啤酒游戏：人机协作挑战")
+st.title("🍺 The Beer Game: A Human-AI Collaboration Challenge")
 
 if st.session_state.get('initialization_error'):
     st.error(st.session_state.initialization_error)
 else:
-    # --- 游戏设置和初始化 ---
+    # --- Game Setup & Instructions ---
     if 'game_state' not in st.session_state or not st.session_state.game_state.get('game_running', False):
-        st.markdown("你将扮演供应链中的一个角色，与另外三个由大语言模型（LLM）驱动的AI代理合作。")
-        st.header("🎮 开始新游戏")
+        
+        # --- NEW: Introduction Section ---
+        st.markdown("---")
+        st.header("📖 Welcome to the Beer Game!")
+        st.markdown("""
+        The Beer Game is a classic supply chain simulation that demonstrates a phenomenon called the **"Bullwhip Effect."** Even with stable customer demand, small variations in orders can amplify as they move up the supply chain, causing massive shortages and overstocks.
+        
+        **Your Goal:** Minimize the total cost for your position in the supply chain. Costs are incurred for holding inventory (**$0.50**/unit/week) and for having a backlog of unfilled orders (**$1.00**/unit/week).
+        """)
+
         col1, col2 = st.columns(2)
-        with col1: llm_personality = st.selectbox("AI '性格'", ('human_like', 'perfect_rational'), format_func=lambda x: x.replace('_', ' ').title())
-        with col2: info_sharing = st.selectbox("信息共享", ('local', 'full'), format_func=lambda x: x.title())
-        if st.button("🚀 开始游戏", type="primary", disabled=(client is None)):
-            init_game_state(llm_personality, info_sharing); st.rerun()
+        with col1:
+            st.subheader("🔗 The Supply Chain")
+            st.markdown("""
+            You will be randomly assigned one of four roles. The other three will be controlled by AI agents.
+            - **Retailer:** Fulfills end-customer demand. Orders from the Wholesaler.
+            - **Wholesaler:** Fulfills Retailer orders. Orders from the Distributor.
+            - **Distributor:** Fulfills Wholesaler orders. Orders from the Factory.
+            - **Factory:** Fulfills Distributor orders. Produces new beer.
+            """)
+        with col2:
+            st.subheader("⏳ The Challenge: Delays!")
+            st.markdown("""
+            The key challenge is managing delays. There is a **communication delay** for orders to reach your supplier and a **shipping delay** for goods to arrive. You must order enough to meet future demand without creating a huge pile of expensive inventory.
+            """)
+        
+        st.subheader("🎮 How to Play This Version")
+        st.markdown("""
+        1.  **Configure the Game:** Choose the AI's behavior and the level of information sharing.
+        2.  **Get Your Role:** You will be randomly assigned a role.
+        3.  **Make Your Decision (Two Steps):**
+            - **Step 1:** Based on your current status, submit your **initial order**.
+            - **Step 2:** After submitting, you will see an **AI suggestion**. You can either follow it or stick to your own judgment when submitting your **final order**.
+        4.  **Advance:** Once you submit your final order, the week advances, and all AI agents make their moves.
+        """)
+        st.markdown("---")
+        
+        # --- Game Configuration ---
+        st.header("⚙️ Game Configuration")
+        c1, c2 = st.columns(2)
+        with c1:
+             llm_personality = st.selectbox("AI Agent 'Personality'", ('human_like', 'perfect_rational'), format_func=lambda x: x.replace('_', ' ').title(), help="**Human-like:** Tends to react emotionally, potentially over-ordering. **Perfect Rational:** Uses a mathematical heuristic to make stable, logical decisions.")
+        with c2:
+            info_sharing = st.selectbox("Information Sharing Level", ('local', 'full'), format_func=lambda x: x.title(), help="**Local:** You and the AI agents can only see your own inventory and incoming orders. **Full:** Everyone can see the entire supply chain's status and the true end-customer demand.")
+        
+        if st.button("🚀 Start Game", type="primary", disabled=(client is None)):
+            init_game_state(llm_personality, info_sharing)
+            st.rerun()
 
-    # --- 游戏主界面 ---
+    # --- Main Game Interface ---
     elif 'game_state' in st.session_state and st.session_state.game_state.get('game_running'):
         state = st.session_state.game_state
         week, human_role, echelons, info_sharing = state['week'], state['human_role'], state['echelons'], state['info_sharing']
         
-        st.header(f"第 {week} 周 / 共 {WEEKS} 周")
-        st.subheader(f"你的角色: **{human_role}** | AI模式: **{state['llm_personality'].replace('_', ' ')}** | 信息: **{state['info_sharing']}**")
+        st.header(f"Week {week} / {WEEKS}")
+        st.subheader(f"Your Role: **{human_role}** | AI Mode: **{state['llm_personality'].replace('_', ' ')}** | Information: **{state['info_sharing']}**")
         
-        # --- 核心改动：根据信息模式显示面板 ---
         st.markdown("---")
-        st.subheader("供应链状态")
+        st.subheader("Supply Chain Status")
         if info_sharing == 'full':
             cols = st.columns(4)
             for i, name in enumerate(["Retailer", "Wholesaler", "Distributor", "Factory"]):
                 with cols[i]:
                     e, icon = echelons[name], "👤" if name == human_role else "🤖"
-                    st.markdown(f"##### {icon} {name} {'(你)' if name == human_role else ''}")
-                    st.metric("库存", e['inventory']); st.metric("缺货", e['backlog'])
-                    st.write(f"收到订单: **{e['incoming_order']}**")
-                    st.write(f"下周到货: **{list(e['incoming_shipments'])[0] if e['incoming_shipments'] else 0}**")
+                    st.markdown(f"##### {icon} {name} {'(You)' if name == human_role else ''}")
+                    st.metric("Inventory", e['inventory']); st.metric("Backlog", e['backlog'])
+                    st.write(f"Incoming Order: **{e['incoming_order']}**")
+                    st.write(f"Arriving Next Week: **{list(e['incoming_shipments'])[0] if e['incoming_shipments'] else 0}**")
         else: # local information
-            st.info("在本地信息模式下，你只能看到你自己的状态。")
+            st.info("In Local Information mode, you can only see your own status dashboard.")
             e = echelons[human_role]
-            st.markdown(f"### 👤 {human_role} (你的面板)")
+            st.markdown(f"### 👤 {human_role} (Your Dashboard)")
             col1, col2, col3, col4 = st.columns(4)
-            col1.metric("当前库存", e['inventory'])
-            col2.metric("当前缺货/积压", e['backlog'])
-            col3.write(f"**本周收到订单:**\n# {e['incoming_order']}")
-            col4.write(f"**下周预计到货:**\n# {list(e['incoming_shipments'])[0] if e['incoming_shipments'] else 0}")
+            col1.metric("Current Inventory", e['inventory'])
+            col2.metric("Current Backlog", e['backlog'])
+            col3.write(f"**Incoming Order (This Week):**\n# {e['incoming_order']}")
+            col4.write(f"**Shipment Arriving (Next Week):**\n# {list(e['incoming_shipments'])[0] if e['incoming_shipments'] else 0}")
         st.markdown("---")
 
-        # --- 核心改动：两阶段决策流程 ---
-        st.header("你的决策")
+        # --- Two-Step Decision UI ---
+        st.header("Your Decision")
         human_echelon_state = echelons[human_role]
 
-        # 阶段一：提交初步订单
         if state['decision_step'] == 'initial_order':
             with st.form(key="initial_order_form"):
-                st.markdown("#### **第一步**: 请根据你看到的信息，提交你的 **初步** 订单。")
-                initial_order = st.number_input("你的初步订单数量:", min_value=0, step=1, value=human_echelon_state['incoming_order'])
-                if st.form_submit_button("提交初步订单，查看AI建议", type="primary"):
+                st.markdown("#### **Step 1:** Based on the information available, submit your **initial** order.")
+                initial_order = st.number_input("Your Initial Order Quantity:", min_value=0, step=1, value=human_echelon_state['incoming_order'])
+                if st.form_submit_button("Submit Initial Order & See AI Suggestion", type="primary"):
                     state['human_initial_order'] = int(initial_order)
                     state['decision_step'] = 'final_order'
                     st.rerun()
-
-        # 阶段二：结合AI建议，提交最终订单
+        
         elif state['decision_step'] == 'final_order':
-            st.success(f"你提交的初步订单是: **{state['human_initial_order']}** 单位。")
+            st.success(f"Your initial order was: **{state['human_initial_order']}** units.")
             prompt_sugg = get_llm_prompt(human_echelon_state, week, state['llm_personality'], state['info_sharing'], echelons)
             ai_suggestion, _ = get_llm_order_decision(prompt_sugg, f"{human_role} (Suggestion)")
             
             with st.form(key="final_order_form"):
-                st.markdown(f"#### **第二步**: AI的建议订单是 **{ai_suggestion}** 单位。")
-                st.markdown("请结合AI建议，提交你的 **最终** 订单。这将结束本周。")
-                final_order = st.number_input("你的最终订单数量:", min_value=0, step=1, value=ai_suggestion)
-                if st.form_submit_button("提交最终订单并进入下一周"):
+                st.markdown(f"#### **Step 2:** The AI suggests ordering **{ai_suggestion}** units.")
+                st.markdown("Considering the AI's advice, submit your **final** order to end the week.")
+                final_order = st.number_input("Your Final Order Quantity:", min_value=0, step=1, value=ai_suggestion)
+                if st.form_submit_button("Submit Final Order & Advance to Next Week"):
                     step_game(int(final_order), state['human_initial_order'], ai_suggestion)
                     st.rerun()
 
-        st.sidebar.header("游戏信息")
-        st.sidebar.markdown(f"**游戏ID**: `{state['participant_id']}` | **当前周**: {week}")
-        if st.sidebar.button("🔄 重置游戏"):
+        st.sidebar.header("Game Info")
+        st.sidebar.markdown(f"**Game ID**: `{state['participant_id']}`\n\n**Current Week**: {week}")
+        if st.sidebar.button("🔄 Reset Game"):
             del st.session_state.game_state; st.rerun()
 
-    # --- 游戏结束界面 ---
+    # --- Game Over Interface ---
     if 'game_state' in st.session_state and not st.session_state.game_state.get('game_running', False) and st.session_state.game_state['week'] > WEEKS:
-        st.header("🎉 游戏结束！")
+        st.header("🎉 Game Over!")
         state = st.session_state.game_state
         logs_df = pd.json_normalize(state['logs'])
         fig = plot_results(logs_df, f"Beer Game (Human: {state['human_role']})\n(AI: {state['llm_personality']} | Info: {state['info_sharing']})", state['human_role'])
         st.pyplot(fig)
         save_logs_and_upload(state)
-        if st.button("✨ 开始一局新游戏"):
+        if st.button("✨ Start a New Game"):
             del st.session_state.game_state; st.rerun()