Update app.py

app.py

@@ -1,5 +1,5 @@
 # app.py
-# @title 啤酒游戏最终整合版 (Streamlit 交互应用 + Hugging Face 日志上传) - 已修复版本
+# @title 啤酒游戏最终整合版 (v3 - 两阶段决策 + 信息隔离)
 
 # -----------------------------------------------------------------------------
 # 1. 导入必要的库
@@ -17,14 +17,13 @@ import uuid
 import os
 from pathlib import Path
 from datetime import datetime
-from huggingface_hub import HfApi, upload_file
+from huggingface_hub import HfApi
 
 # -----------------------------------------------------------------------------
 # 0. 页面配置 (必须是第一个Streamlit命令)
 # -----------------------------------------------------------------------------
 st.set_page_config(page_title="啤酒游戏-人机协作版", layout="wide")
 
-
 # -----------------------------------------------------------------------------
 # 2. 配置游戏核心参数和API密钥
 # -----------------------------------------------------------------------------
@@ -42,57 +41,41 @@ BACKLOG_COST = 1.0
 # --- 模型和日志配置 ---
 OPENAI_MODEL = "gpt-4o-mini"
 LOCAL_LOG_DIR = Path("logs")
-LOCAL_LOG_DIR.mkdir(exist_ok=True) # Ensure the log directory exists
+LOCAL_LOG_DIR.mkdir(exist_ok=True)
 
-# --- API & Secrets 配置 (从 Streamlit Secrets 读取) ---
+# --- API & Secrets 配置 ---
 try:
-    # OpenAI
     client = openai.OpenAI(api_key=st.secrets["OPENAI_API_KEY"])
-    # Hugging Face
     HF_TOKEN = st.secrets.get("HF_TOKEN")
-    HF_REPO_ID = st.secrets.get("HF_REPO_ID") # e.g., "YourUser/beer-game-logs"
-    if HF_TOKEN:
-        hf_api = HfApi()
-    else:
-        hf_api = None
+    HF_REPO_ID = st.secrets.get("HF_REPO_ID")
+    hf_api = HfApi() if HF_TOKEN else None
 except Exception as e:
-    # 将错误信息显示在主页面，而不是在加载配置时就调用st.error
-    st.session_state.initialization_error = f"启动时读取Secrets出错: {e}. 请确保在Streamlit的Secrets中设置了 OPENAI_API_KEY。可选设置 HF_TOKEN 和 HF_REPO_ID 用于上传日志。"
+    st.session_state.initialization_error = f"启动时读取Secrets出错: {e}。"
     client = None
-    HF_TOKEN = None
-    HF_REPO_ID = None
-    hf_api = None
 else:
     st.session_state.initialization_error = None
 
-
 # -----------------------------------------------------------------------------
-# 3. 游戏核心逻辑函数 (大部分源自代码1, 并为Streamlit适配)
+# 3. 游戏核心逻辑函数
 # -----------------------------------------------------------------------------
 
 def get_customer_demand(week: int) -> int:
-    """定义终端客户需求函数"""
     return 4 if week <= 4 else 8
 
 def init_game_state(llm_personality: str, info_sharing: str):
-    """初始化或重置游戏状态，并储存在 st.session_state 中"""
     roles = ["Retailer", "Wholesaler", "Distributor", "Factory"]
     human_role = random.choice(roles)
-    participant_id = str(uuid.uuid4())[:8] # Generate a unique ID for this game session
+    participant_id = str(uuid.uuid4())[:8]
 
     st.session_state.game_state = {
-        'game_running': True,
-        'participant_id': participant_id,
-        'week': 1,
-        'human_role': human_role,
-        'llm_personality': llm_personality,
-        'info_sharing': info_sharing,
-        'logs': [], # Changed from 'history' to 'logs' for more detailed logging
-        'echelons': {},
+        'game_running': True, 'participant_id': participant_id, 'week': 1,
+        '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,      # 新增：储存玩家的初步订单
     }
 
-    # 为每个角色初始化状态
     for i, name in enumerate(roles):
         upstream = roles[i + 1] if i + 1 < len(roles) else None
         downstream = roles[i - 1] if i - 1 >= 0 else None
@@ -101,64 +84,44 @@ def init_game_state(llm_personality: str, info_sharing: str):
         else: shipping_weeks = SHIPPING_DELAY
 
         st.session_state.game_state['echelons'][name] = {
-            'name': name, 'upstream_name': upstream, 'downstream_name': downstream,
-            'inventory': INITIAL_INVENTORY, 'backlog': INITIAL_BACKLOG,
+            'name': name, 'inventory': INITIAL_INVENTORY, 'backlog': INITIAL_BACKLOG,
             'order_pipeline': deque([0] * ORDER_PASSING_DELAY, maxlen=ORDER_PASSING_DELAY),
             'incoming_shipments': deque([0] * shipping_weeks, maxlen=shipping_weeks),
             'incoming_order': 0, 'order_placed': 0, 'shipment_sent': 0,
-            'weekly_cost': 0, 'total_cost': 0,
+            'weekly_cost': 0, 'total_cost': 0, 'upstream_name': upstream, 'downstream_name': downstream,
         }
-    st.info(f"新游戏开始！AI模式: **{llm_personality} / {info_sharing}**。您的角色: **{human_role}**。本次游戏ID: `{participant_id}`")
-
-
-def get_llm_order_decision(prompt: str, echelon_name: str, current_week: int, personality: str) -> (int, str):
-    """调用 OpenAI API 获取决策，并返回决策和原始文本"""
-    if not client:
-        st.warning("API Key未设置，LLM将使用默认值8。")
-        return 8, "NO_API_KEY_DEFAULT"
+    st.info(f"新游戏开始！AI模式: **{llm_personality} / {info_sharing}**。您的角色: **{human_role}**。")
 
+def get_llm_order_decision(prompt: str, echelon_name: str) -> (int, str):
+    if not client: return 8, "NO_API_KEY_DEFAULT"
     with st.spinner(f"正在为 {echelon_name} 获取AI决策..."):
-        temp = 0.1 if personality == 'perfect_rational' else 0.7
         try:
+            temp = 0.1 if 'rational' in prompt else 0.7
             response = client.chat.completions.create(
                 model=OPENAI_MODEL,
                 messages=[
                     {"role": "system", "content": "You are a supply chain manager playing the Beer Game. Your response must be only an integer number representing your order quantity and nothing else. For example: 8"},
                     {"role": "user", "content": prompt}
                 ],
-                temperature=temp,
-                max_tokens=10
+                temperature=temp, max_tokens=10
             )
             raw_text = response.choices[0].message.content.strip()
             match = re.search(r'\d+', raw_text)
-            if match:
-                return int(match.group(0)), raw_text
-            else:
-                st.warning(f"LLM for {echelon_name} 未返回有效数字，将使用默认值 8。原始返回: '{raw_text}'")
-                return 8, raw_text
+            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}。将使用默认值 8。")
+            st.error(f"API调用失败 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:
-    """生成LLM的提示词 (核心逻辑完全来自代码1)"""
     # (此函数内容与上一版完全相同，为简洁省略，实际代码中应完整保留)
-    base_info = f"""
-Your Current Status at the **{echelon_state['name']}** for **Week {week}**:
-- On-hand inventory: {echelon_state['inventory']} units.
-- Backlog (unfilled orders): {echelon_state['backlog']} units.
-- Incoming order this week (from your customer): {echelon_state['incoming_order']} units.
-- Shipments on the way to you: {list(echelon_state['incoming_shipments'])}
-- Orders you have placed being processed by your supplier: {list(echelon_state['order_pipeline'])}
-"""
-    # 场景 1: 完美理性 x 完全信息
+    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
         target_inventory_level = (stable_demand * total_lead_time) + safety_stock
         inventory_position = (echelon_state['inventory'] - echelon_state['backlog'] + sum(echelon_state['incoming_shipments']) + sum(echelon_state['order_pipeline']))
         optimal_order = max(0, int(target_inventory_level - inventory_position))
         return f"**You are a perfectly rational supply chain AI with full system visibility.**\nYour only goal is to maintain stability and minimize costs based on mathematical optimization.\n**System Analysis:**\n* **Known Stable End-Customer Demand:** {stable_demand} units/week.\n* **Your Current Total Inventory Position:** {inventory_position} units.\n* **Optimal Target Inventory Level:** {target_inventory_level} units.\n* **Mathematically Optimal Order:** The optimal order is **{optimal_order} units**.\n**Your Task:** Confirm this optimal quantity. Respond with a single integer."
-    # 场景 2: 完美理性 x 本地信息
     elif llm_personality == 'perfect_rational' and info_sharing == 'local':
         safety_stock = 4; anchor_demand = echelon_state['incoming_order']
         inventory_correction = safety_stock - (echelon_state['inventory'] - echelon_state['backlog'])
@@ -166,206 +129,214 @@ Your Current Status at the **{echelon_state['name']}** for **Week {week}**:
         calculated_order = anchor_demand + inventory_correction - supply_line
         rational_local_order = max(0, int(calculated_order))
         return f"**You are a perfectly rational supply chain AI with ONLY LOCAL information.**\nYou must use a logical heuristic to make a stable decision. A proven method is \"Anchoring and Adjustment\".\n\n{base_info}\n\n**Rational Calculation (Anchoring & Adjustment):**\n1.  **Anchor on Demand:** Your best guess for future demand is your last incoming order: **{anchor_demand} units**.\n2.  **Adjust for Inventory:** You want to hold a safety stock of {safety_stock} units. Your current stock is {echelon_state['inventory'] - echelon_state['backlog']}. You need to order an extra **{inventory_correction} units** to correct this.\n3.  **Account for Supply Line:** You already have **{supply_line} units** in transit or being processed. These should be subtracted from your new order.\n\n**Final Calculation:**\n* Order = (Anchor Demand) + (Inventory Adjustment) - (Supply Line)\n* Order = {anchor_demand} + {inventory_correction} - {supply_line} = **{rational_local_order} units**.\n\n**Your Task:** Confirm this locally rational quantity. Respond with a single integer."
-    # 场景 3: 类人 x 完全信息
     elif llm_personality == 'human_like' and info_sharing == 'full':
         full_info_str = f"\n**Full Supply Chain Information:**\n- End-Customer Demand this week: {get_customer_demand(week)} units.\n"
         for name, e_state in all_echelons_state.items():
             if name != echelon_state['name']: full_info_str += f"- {name}: Inventory={e_state['inventory']}, Backlog={e_state['backlog']}\n"
         return f"**You are a supply chain manager with full visibility across the entire system.**\nYou can see everyone's inventory and the real customer demand. Your goal is to use this information to make a smart, coordinated decision. However, you are still human and might get anxious about your own stock levels.\n{base_info}\n{full_info_str}\n**Your Task:** Look at the full picture, especially the stable end-customer demand. Try to avoid causing the bullwhip effect. However, also consider your own inventory pressure. What quantity should you order this week? Respond with a single integer."
-    # 场景 4: 类人 x 本地信息
     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):
-    """推进一周的游戏进程，并记录详细日志"""
+
+def step_game(human_final_order: int, human_initial_order: int, ai_suggestion: int):
+    """推进一周的游戏进程，并记录包括两阶段决策在内的详细日志"""
     state = st.session_state.game_state
-    week = state['week']
-    echelons = state['echelons']
-    human_role = state['human_role']
-    llm_personality = state['llm_personality']
-    info_sharing = state['info_sharing']
+    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 = {}
 
-    # --- 游戏流程 ---
-    # 1. 工厂生产完成 & 2. 各环节接收货物
+    # 游戏流程 (与之前相同)
     factory_state = echelons["Factory"]
     if state['factory_production_pipeline']: factory_state['inventory'] += state['factory_production_pipeline'].popleft()
     for name in ["Retailer", "Wholesaler", "Distributor"]:
         if echelons[name]['incoming_shipments']: echelons[name]['inventory'] += echelons[name]['incoming_shipments'].popleft()
-    # 3. 各环节接收订单
     for name in echelon_order:
         if name == "Retailer": echelons[name]['incoming_order'] = get_customer_demand(week)
         else:
             downstream = echelons[name]['downstream_name']
             if downstream and echelons[downstream]['order_pipeline']:
                 echelons[name]['incoming_order'] = echelons[downstream]['order_pipeline'].popleft()
-    # 4. 满足订单并发货
     for name in echelon_order:
-        e = echelons[name]
-        demand = e['incoming_order'] + e['backlog']
-        e['shipment_sent'] = min(e['inventory'], demand)
-        e['inventory'] -= e['shipment_sent']
-        e['backlog'] = demand - e['shipment_sent']
-    # 5. 发货在途
+        e = echelons[name]; demand = e['incoming_order'] + e['backlog']
+        e['shipment_sent'] = min(e['inventory'], demand); e['inventory'] -= e['shipment_sent']; e['backlog'] = demand - e['shipment_sent']
     for sender in ["Factory", "Distributor", "Wholesaler"]:
         receiver = echelons[sender]['downstream_name']
         if receiver: echelons[receiver]['incoming_shipments'].append(echelons[sender]['shipment_sent'])
 
-    # 6. 各环节下订单
+    # 各环节下订单
     for name in echelon_order:
         e = echelons[name]
         if name == human_role:
-            order_amount, raw_resp = human_final_order, "HUMAN_INPUT"
-            st.sidebar.write(f"✔️ 你 ({name}) 的最终订单: {order_amount}")
+            order_amount, raw_resp = human_final_order, "HUMAN_FINAL_INPUT"
         else:
             prompt = get_llm_prompt(e, week, llm_personality, info_sharing, echelons)
-            order_amount, raw_resp = get_llm_order_decision(prompt, name, week, llm_personality)
-            st.sidebar.write(f"🤖 AI ({name}) 的订单: {order_amount}")
+            order_amount, raw_resp = get_llm_order_decision(prompt, name)
         llm_raw_responses[name] = raw_resp
         e['order_placed'] = max(0, order_amount)
         if name != "Factory": e['order_pipeline'].append(e['order_placed'])
 
-    # 7. 工厂安排生产
     state['factory_production_pipeline'].append(echelons["Factory"]['order_placed'])
 
-    # 8. 更新成本
+    # 更新成本和记录日志
+    log_entry = {'timestamp': datetime.utcnow().isoformat() + "Z", 'week': week, **state}
+    del log_entry['echelons'], log_entry['factory_production_pipeline'] # 移除复杂对象
     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']
-
-    # 9. 记录详细日志
-    log_entry = {
-        'timestamp': datetime.utcnow().isoformat() + "Z", 'week': week,
-        'participant_id': state['participant_id'], 'human_role': human_role,
-        'llm_personality': llm_personality, 'info_sharing': info_sharing,
-        'customer_demand': get_customer_demand(week),
-    }
-    for name in echelon_order:
-        e = echelons[name]
-        log_entry[f'{name}.inventory'] = e['inventory']
-        log_entry[f'{name}.backlog'] = e['backlog']
-        log_entry[f'{name}.incoming_order'] = e['incoming_order']
-        log_entry[f'{name}.order_placed'] = e['order_placed']
-        log_entry[f'{name}.shipment_sent'] = e['shipment_sent']
-        log_entry[f'{name}.weekly_cost'] = e['weekly_cost']
-        log_entry[f'{name}.total_cost'] = e['total_cost']
+        e['weekly_cost'] = (e['inventory'] * HOLDING_COST) + (e['backlog'] * BACKLOG_COST); e['total_cost'] += e['weekly_cost']
+        for key in ['inventory', 'backlog', 'incoming_order', 'order_placed', 'shipment_sent', 'weekly_cost', 'total_cost']:
+            log_entry[f'{name}.{key}'] = e[key]
         log_entry[f'{name}.llm_raw_response'] = llm_raw_responses.get(name, "")
+    
+    # 新增：记录两阶段决策数据
+    log_entry[f'{human_role}.initial_order'] = human_initial_order
+    log_entry[f'{human_role}.ai_suggestion'] = ai_suggestion
+    
     state['logs'].append(log_entry)
 
-    # 10. 推进周数
+    # 推进周数并重置决策步骤
     state['week'] += 1
-    if state['week'] > WEEKS:
-        state['game_running'] = False
+    state['decision_step'] = 'initial_order'
+    if state['week'] > WEEKS: state['game_running'] = False
 
-def plot_results(df: pd.DataFrame, title: str):
-    """绘制结果图表 (源自代码1)"""
-    fig, axes = plt.subplots(3, 1, figsize=(12, 16)); fig.suptitle(title, fontsize=16)
+
+def plot_results(df: pd.DataFrame, title: str, human_role: str):
+    fig, axes = plt.subplots(4, 1, figsize=(12, 22)) # 增加一个子图
+    fig.suptitle(title, fontsize=16)
     echelons = ['Retailer', 'Wholesaler', 'Distributor', 'Factory']
-    # 提取用于绘图的数据
+    
     plot_data = []
     for _, row in df.iterrows():
         for e in echelons:
-            plot_data.append({
-                'week': row['week'], 'echelon': e,
+            plot_data.append({'week': row['week'], 'echelon': e,
                 'inventory': row[f'{e}.inventory'], 'order_placed': row[f'{e}.order_placed'],
-                'total_cost': row[f'{e}.total_cost']
-            })
+                'total_cost': row[f'{e}.total_cost']})
     plot_df = pd.DataFrame(plot_data)
-    # 绘图逻辑 (与之前版本相同)
+
+    # 图1: 库存
     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='--')
+
+    # 图2: 订单 (牛鞭效应)
     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()
+
+    # 图3: 成本
     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')
+
+    # 新增图4: 人类玩家决策分析
+    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'
+    }, 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='--')
+    
     plt.tight_layout(rect=[0, 0, 1, 0.96]); return fig
 
-def save_logs_and_upload(state: dict):
-    """在游戏结束后，保存日志到本地并尝试上传到Hugging Face"""
-    if not state.get('logs'):
-        st.warning("没有可保存的日志。")
-        return
 
+def save_logs_and_upload(state: dict):
+    # (此函数内容与上一版完全相同)
+    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}`")
-
-    # 提供下载按钮
     with open(fname, "rb") as f:
         st.download_button("📥 下载日志CSV文件", data=f, file_name=fname.name, mime="text/csv")
-
-    # 尝试上传到Hugging Face
     if HF_TOKEN and HF_REPO_ID and hf_api:
         with st.spinner("正在上传日志到 Hugging Face Hub..."):
             try:
-                dest_path = f"logs/{fname.name}"
-                url = hf_api.upload_file(
-                    path_or_fileobj=str(fname),
-                    path_in_repo=dest_path,
-                    repo_id=HF_REPO_ID,
-                    repo_type="dataset",
-                    token=HF_TOKEN
-                )
+                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})")
             except Exception as e:
                 st.error(f"上传到 Hugging Face 失败: {e}")
-    else:
-        st.info("未配置Hugging Face的 HF_TOKEN 或 HF_REPO_ID, 将跳过上传。")
 
 # -----------------------------------------------------------------------------
 # 4. Streamlit UI 界面
 # -----------------------------------------------------------------------------
 st.title("🍺 啤酒游戏：人机协作挑战")
 
-# 检查初始化时是否有错误
 if st.session_state.get('initialization_error'):
     st.error(st.session_state.initialization_error)
 else:
-    st.markdown("你将扮演供应链中的一个角色，与另外三个由大语言模型（LLM）驱动的AI代理合作。")
-
     # --- 游戏设置和初始化 ---
     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("🎮 开始新游戏")
         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())
+        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()
+            init_game_state(llm_personality, info_sharing); st.rerun()
 
     # --- 游戏主界面 ---
     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 = state['week'], state['human_role'], state['echelons']
+        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']}**")
-        cols = st.columns(4)
-        for i, name in enumerate(["Retailer", "Wholesaler", "Distributor", "Factory"]):
-            with cols[i]:
-                e, title_icon = echelons[name], "👤" if name == human_role else "🤖"
-                st.markdown(f"### {title_icon} {name} {'(你)' if name == human_role else '(AI)'}")
-                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("---")
+        st.subheader("供应链状态")
+        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}**")
+        else: # local information
+            st.info("在本地信息模式下，你只能看到你自己的状态。")
+            e = echelons[human_role]
+            st.markdown(f"### 👤 {human_role} (你的面板)")
+            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}")
         st.markdown("---")
+
+        # --- 核心改动：两阶段决策流程 ---
         st.header("你的决策")
         human_echelon_state = echelons[human_role]
-        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)", week, state['llm_personality'])
-        st.info(f"💡 AI建议你 ({human_role}) 本周向上游订购 **{ai_suggestion}** 单位。")
-        with st.form(key="order_form"):
-            final_order = st.number_input("请输入你的最终订单数量:", min_value=0, step=1, value=ai_suggestion)
-            if st.form_submit_button(label="✅ 提交订单并进入下一周"):
-                step_game(int(final_order)); st.rerun()
+
+        # 阶段一：提交初步订单
+        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"):
+                    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']}** 单位。")
+            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("提交最终订单并进入下一周"):
+                    step_game(int(final_order), state['human_initial_order'], ai_suggestion)
+                    st.rerun()
+
         st.sidebar.header("游戏信息")
-        st.sidebar.markdown(f"**游戏ID**: `{state['participant_id']}`")
-        st.sidebar.markdown(f"**当前周**: {week-1} (已完成)")
+        st.sidebar.markdown(f"**游戏ID**: `{state['participant_id']}` | **当前周**: {week}")
         if st.sidebar.button("🔄 重置游戏"):
             del st.session_state.game_state; st.rerun()
 
@@ -374,10 +345,8 @@ else:
         st.header("🎉 游戏结束！")
         state = st.session_state.game_state
         logs_df = pd.json_normalize(state['logs'])
-        title = f"Beer Game (Human: {state['human_role']})\n(AI: {state['llm_personality'].replace('_', ' ').title()} | Info: {state['info_sharing'].title()})"
-        fig = plot_results(logs_df, title)
+        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("✨ 开始一局新游戏"):
             del st.session_state.game_state; st.rerun()