Upload 6 files

app.py

@@ -52,12 +52,13 @@ def restart_game() -> tuple:
         (空聊天历史, 初始状态面板, 隐藏选项按钮×3, 空游戏会话,
          禁用文本输入框, 重置角色名称)
     """
+    loading = _get_loading_button_updates()
     return (
         [],                                                          # 清空聊天历史
         "## 等待开始...\n\n请输入角色名称并点击「开始冒险」",         # 重置状态面板
-        gr.update(visible=False, interactive=False),                  # 隐藏选项按钮1
-        gr.update(visible=False, interactive=False),                  # 隐藏选项按钮2
-        gr.update(visible=False, interactive=False),                  # 隐藏选项按钮3
+        loading[0],                                                   # 占位选项按钮1
+        loading[1],                                                   # 占位选项按钮2
+        loading[2],                                                   # 占位选项按钮3
         {},                                                          # 清空游戏会话
         gr.update(value="", interactive=False),                       # 禁用并清空文本输入
         gr.update(value="旅人"),                                      # 重置角色名称
@@ -69,12 +70,11 @@ def restart_game() -> tuple:
 # ============================================================
 
 
-def start_game(player_name: str, game_session: dict) -> tuple:
+def start_game(player_name: str, game_session: dict):
     """
-    开始新游戏：生成开场叙事。
+    开始新游戏：流式生成开场叙事。
 
-    Returns:
-        (聊天历史, 状态面板文本, 选项按钮文本, 游戏会话)
+    使用生成器 yield 实现流式输出，让用户看到文字逐步出现。
     """
     if not player_name.strip():
         player_name = "旅人"
@@ -83,58 +83,89 @@ def start_game(player_name: str, game_session: dict) -> tuple:
     game_session = create_new_game(player_name)
     game_session["started"] = True
 
-    # 生成开场
-    result = game_session["story"].generate_opening()
+    # 初始 yield：显示加载状态，按钮保持可见但禁用
+    chat_history = [{"role": "assistant", "content": "⏳ 正在生成开场..."}]
+    status_text = _format_status_panel(game_session["game_state"])
+    loading = _get_loading_button_updates()
 
-    # 保存当前选项
-    game_session["current_options"] = result.get("options", [])
+    yield (
+        chat_history, status_text,
+        loading[0], loading[1], loading[2],
+        game_session,
+        gr.update(interactive=False),
+    )
 
-    # 构建聊天历史
-    story_text = result["story_text"]
-    options_text = _format_options(result.get("options", []))
-    full_message = f"{story_text}\n\n{options_text}"
+    # 流式生成开场（选项仅在流结束后从 final 事件中提取，流式期间不解析选项）
+    story_text = ""
+    final_result = None
+
+    for update in game_session["story"].generate_opening_stream():
+        if update["type"] == "story_chunk":
+            story_text = update["text"]
+            chat_history[-1]["content"] = story_text
+            yield (
+                chat_history, status_text,
+                loading[0], loading[1], loading[2],
+                game_session,
+                gr.update(interactive=False),
+            )
+        elif update["type"] == "final":
+            final_result = update
+
+    # ★ 只在数据流完全结束后，从 final_result 中提取选项
+    if final_result:
+        story_text = final_result.get("story_text", story_text)
+        options = final_result.get("options", [])
+    else:
+        options = []
 
-    chat_history = [{"role": "assistant", "content": full_message}]
+    # ★ 安全兜底：强制确保恰好 3 个选项
+    options = _ensure_min_options(options, 3)
 
-    # 状态面板
-    status_text = _format_status_panel(game_session["game_state"])
+    # 最终 yield：显示完整文本 + 选项 + 启用按钮
+    game_session["current_options"] = options
+    options_text = _format_options(options)
+    full_message = f"{story_text}\n\n{options_text}"
 
-    # 选项按钮更新（静态按钮 + 动态更新模式）
-    btn_updates = _get_button_updates(result.get("options", []))
+    chat_history[-1]["content"] = full_message
+    status_text = _format_status_panel(game_session["game_state"])
+    btn_updates = _get_button_updates(options)
 
-    return (
-        chat_history,
-        status_text,
+    yield (
+        chat_history, status_text,
         btn_updates[0], btn_updates[1], btn_updates[2],
         game_session,
-        gr.update(interactive=True),  # 文本输入框
+        gr.update(interactive=True),
     )
 
 
-def process_user_input(user_input: str, chat_history: list, game_session: dict) -> tuple:
+def process_user_input(user_input: str, chat_history: list, game_session: dict):
     """
-    处理用户文本输入。
+    处理用户文本输入（流式版本）。
 
     流程：
     1. NLU 引擎解析意图
-    2. 叙事引擎生成故事
-    3. 更新 UI
+    2. 叙事引擎流式生成故事
+    3. 逐步更新 UI
     """
     if not game_session or not game_session.get("started"):
         chat_history = chat_history or []
         chat_history.append({"role": "assistant", "content": "请先点击「开始冒险」按钮！"})
-        return (
+        loading = _get_loading_button_updates()
+        yield (
             chat_history, "",
-            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+            loading[0], loading[1], loading[2],
             game_session,
         )
+        return
 
     if not user_input.strip():
-        return (
+        yield (
             chat_history, _format_status_panel(game_session["game_state"]),
             gr.update(), gr.update(), gr.update(),
             game_session,
         )
+        return
 
     gs: GameState = game_session["game_state"]
     nlu: NLUEngine = game_session["nlu"]
@@ -144,61 +175,103 @@ def process_user_input(user_input: str, chat_history: list, game_session: dict)
     if gs.is_game_over():
         chat_history.append({"role": "user", "content": user_input})
         chat_history.append({"role": "assistant", "content": "游戏已结束。请点击「重新开始」按钮开始新的冒险。"})
-        return (
+        yield (
             chat_history,
             _format_status_panel(gs),
             gr.update(value="重新开始", visible=True, interactive=True),
-            gr.update(visible=False), gr.update(visible=False),
+            gr.update(value="...", visible=True, interactive=False),
+            gr.update(value="...", visible=True, interactive=False),
             game_session,
         )
+        return
 
     # 1. NLU 解析
     intent = nlu.parse_intent(user_input)
 
-    # 2. 生成故事
-    result = story.generate_story(intent)
-
-    # 3. 更新选项
-    game_session["current_options"] = result.get("options", [])
-
-    # 4. 构建聊天消息
+    # 2. 添加用户消息 + 空的 assistant 消息（用于流式填充）
     chat_history.append({"role": "user", "content": user_input})
+    chat_history.append({"role": "assistant", "content": "⏳ 正在生成..."})
 
-    # 变更日志
-    change_log = result.get("change_log", [])
-    log_text = ""
-    if change_log:
-        log_text = "\n".join(f"  {c}" for c in change_log)
-        log_text = f"\n\n**状态变化：**\n{log_text}"
-
-    # 一致性问题
-    issues = result.get("consistency_issues", [])
-    issues_text = ""
-    if issues:
-        issues_text = "\n".join(f"  {i}" for i in issues)
-        issues_text = f"\n\n**一致性提示：**\n{issues_text}"
+    # 按钮保持可见但禁用，防止流式期间点击
+    loading = _get_loading_button_updates()
+    yield (
+        chat_history,
+        _format_status_panel(gs),
+        loading[0], loading[1], loading[2],
+        game_session,
+    )
 
-    # 选项文本
-    options_text = _format_options(result.get("options", []))
+    # 3. 流式生成故事
+    final_result = None
+    for update in story.generate_story_stream(intent):
+        if update["type"] == "story_chunk":
+            chat_history[-1]["content"] = update["text"]
+            yield (
+                chat_history,
+                _format_status_panel(gs),
+                loading[0], loading[1], loading[2],
+                game_session,
+            )
+        elif update["type"] == "final":
+            final_result = update
+
+    # 4. 最终更新：完整文本 + 状态变化 + 选项 + 按钮
+    if final_result:
+        # ★ 安全兜底：强制确保恰好 3 个选项
+        options = _ensure_min_options(final_result.get("options", []), 3)
+        game_session["current_options"] = options
+
+        change_log = final_result.get("change_log", [])
+        log_text = ""
+        if change_log:
+            log_text = "\n".join(f"  {c}" for c in change_log)
+            log_text = f"\n\n**状态变化：**\n{log_text}"
+
+        issues = final_result.get("consistency_issues", [])
+        issues_text = ""
+        if issues:
+            issues_text = "\n".join(f"  {i}" for i in issues)
+            issues_text = f"\n\n**一致性提示：**\n{issues_text}"
+
+        options_text = _format_options(options)
+        full_message = f"{final_result['story_text']}{log_text}{issues_text}\n\n{options_text}"
+        chat_history[-1]["content"] = full_message
+
+        status_text = _format_status_panel(gs)
+        btn_updates = _get_button_updates(options)
+
+        yield (
+            chat_history,
+            status_text,
+            btn_updates[0], btn_updates[1], btn_updates[2],
+            game_session,
+        )
+    else:
+        # ★ 兜底：final_result 为空，说明流式生成未产生 final ��件
+        logger.warning("流式生成未产生 final 事件，使用兜底文本")
+        fallback_text = "你环顾四周，思考着接下来该做什么..."
+        fallback_options = _ensure_min_options([], 3)
+        game_session["current_options"] = fallback_options
 
-    full_message = f"{result['story_text']}{log_text}{issues_text}\n\n{options_text}"
-    chat_history.append({"role": "assistant", "content": full_message})
+        options_text = _format_options(fallback_options)
+        full_message = f"{fallback_text}\n\n{options_text}"
+        chat_history[-1]["content"] = full_message
 
-    # 5. 更新状态面板
-    status_text = _format_status_panel(gs)
-    btn_updates = _get_button_updates(result.get("options", []))
+        status_text = _format_status_panel(gs)
+        btn_updates = _get_button_updates(fallback_options)
 
-    return (
-        chat_history,
-        status_text,
-        btn_updates[0], btn_updates[1], btn_updates[2],
-        game_session,
-    )
+        yield (
+            chat_history,
+            status_text,
+            btn_updates[0], btn_updates[1], btn_updates[2],
+            game_session,
+        )
+        return
 
 
-def process_option_click(option_idx: int, chat_history: list, game_session: dict) -> tuple:
+def process_option_click(option_idx: int, chat_history: list, game_session: dict):
     """
-    处理玩家点击选项按钮。
+    处理玩家点击选项按钮（流式版本）。
 
     Args:
         option_idx: 选项索引 (0, 1, 2)
@@ -206,20 +279,23 @@ def process_option_click(option_idx: int, chat_history: list, game_session: dict
     if not game_session or not game_session.get("started"):
         chat_history = chat_history or []
         chat_history.append({"role": "assistant", "content": "请先点击「开始冒险」按钮！"})
-        return (
+        loading = _get_loading_button_updates()
+        yield (
             chat_history, "",
-            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+            loading[0], loading[1], loading[2],
             game_session,
         )
+        return
 
     options = game_session.get("current_options", [])
     if option_idx >= len(options):
-        return (
+        yield (
             chat_history,
             _format_status_panel(game_session["game_state"]),
             gr.update(), gr.update(), gr.update(),
             game_session,
         )
+        return
 
     selected_option = options[option_idx]
     gs: GameState = game_session["game_state"]
@@ -227,76 +303,234 @@ def process_option_click(option_idx: int, chat_history: list, game_session: dict
 
     # 检查特殊选项：重新开始
     if selected_option.get("action_type") == "RESTART":
-        full_result = start_game(gs.player.name, game_session)
-        # start_game 返回 7 个值（含 user_input 更新），此处只需前 6 个
-        return full_result[:6]
+        # 重新开始时使用流式开场
+        game_session = create_new_game(gs.player.name)
+        game_session["started"] = True
+
+        chat_history = [{"role": "assistant", "content": "⏳ 正在重新生成开场..."}]
+        status_text = _format_status_panel(game_session["game_state"])
+        loading = _get_loading_button_updates()
+
+        yield (
+            chat_history, status_text,
+            loading[0], loading[1], loading[2],
+            game_session,
+        )
+
+        story_text = ""
+        restart_final = None
+
+        for update in game_session["story"].generate_opening_stream():
+            if update["type"] == "story_chunk":
+                story_text = update["text"]
+                chat_history[-1]["content"] = story_text
+                yield (
+                    chat_history, status_text,
+                    loading[0], loading[1], loading[2],
+                    game_session,
+                )
+            elif update["type"] == "final":
+                restart_final = update
+
+        # ★ 只在流完全结束后提取选项
+        if restart_final:
+            story_text = restart_final.get("story_text", story_text)
+            restart_options = restart_final.get("options", [])
+        else:
+            restart_options = []
+
+        # ★ 安全兜底：强制确保恰好 3 个选项
+        restart_options = _ensure_min_options(restart_options, 3)
+        game_session["current_options"] = restart_options
+        options_text = _format_options(restart_options)
+        full_message = f"{story_text}\n\n{options_text}"
+        chat_history[-1]["content"] = full_message
+
+        status_text = _format_status_panel(game_session["game_state"])
+        btn_updates = _get_button_updates(restart_options)
+
+        yield (
+            chat_history, status_text,
+            btn_updates[0], btn_updates[1], btn_updates[2],
+            game_session,
+        )
+        return
 
     # 检查特殊选项：退出
     if selected_option.get("action_type") == "QUIT":
         chat_history.append({"role": "user", "content": f"选择: {selected_option['text']}"})
         chat_history.append({"role": "assistant", "content": "感谢游玩 StoryWeaver！\n你的冒险到此结束，但故事永远不会真正终结...\n\n点击「开始冒险」可以重新开始。"})
-        return (
+        yield (
             chat_history,
             _format_status_panel(gs),
             gr.update(value="重新开始", visible=True, interactive=True),
-            gr.update(visible=False), gr.update(visible=False),
+            gr.update(value="...", visible=True, interactive=False),
+            gr.update(value="...", visible=True, interactive=False),
             game_session,
         )
+        return
 
-    # 正常选项处理
+    # 正常选项处理：流式生成
     chat_history.append({"role": "user", "content": f"选择: {selected_option['text']}"})
+    chat_history.append({"role": "assistant", "content": "⏳ 正在生成..."})
 
-    result = story.process_option_selection(selected_option)
-    game_session["current_options"] = result.get("options", [])
-
-    # 构建响应消息
-    change_log = result.get("change_log", [])
-    log_text = ""
-    if change_log:
-        log_text = "\n".join(f"  {c}" for c in change_log)
-        log_text = f"\n\n**状态变化：**\n{log_text}"
-
-    options_text = _format_options(result.get("options", []))
-    full_message = f"{result['story_text']}{log_text}\n\n{options_text}"
-    chat_history.append({"role": "assistant", "content": full_message})
-
-    status_text = _format_status_panel(gs)
-    btn_updates = _get_button_updates(result.get("options", []))
-
-    return (
+    # 按钮保持可见但禁用
+    loading = _get_loading_button_updates()
+    yield (
         chat_history,
-        status_text,
-        btn_updates[0], btn_updates[1], btn_updates[2],
+        _format_status_panel(gs),
+        loading[0], loading[1], loading[2],
         game_session,
     )
 
+    final_result = None
+    for update in story.process_option_selection_stream(selected_option):
+        if update["type"] == "story_chunk":
+            chat_history[-1]["content"] = update["text"]
+            yield (
+                chat_history,
+                _format_status_panel(gs),
+                loading[0], loading[1], loading[2],
+                game_session,
+            )
+        elif update["type"] == "final":
+            final_result = update
+
+    if final_result:
+        # ★ 安全兜底：强制确保恰好 3 个选项
+        options = _ensure_min_options(final_result.get("options", []), 3)
+        game_session["current_options"] = options
+
+        change_log = final_result.get("change_log", [])
+        log_text = ""
+        if change_log:
+            log_text = "\n".join(f"  {c}" for c in change_log)
+            log_text = f"\n\n**状态变化：**\n{log_text}"
+
+        options_text = _format_options(options)
+        full_message = f"{final_result['story_text']}{log_text}\n\n{options_text}"
+        chat_history[-1]["content"] = full_message
+
+        status_text = _format_status_panel(gs)
+        btn_updates = _get_button_updates(options)
+
+        yield (
+            chat_history, status_text,
+            btn_updates[0], btn_updates[1], btn_updates[2],
+            game_session,
+        )
+    else:
+        # ★ 兜底：final_result 为空，说明流式生成未产生 final 事件
+        logger.warning("[选项点击] 流式生成未产生 final 事件，使用兜底文本")
+        fallback_text = "你环顾四周，思考着接下来该做什么..."
+        fallback_options = _ensure_min_options([], 3)
+        game_session["current_options"] = fallback_options
+
+        options_text = _format_options(fallback_options)
+        full_message = f"{fallback_text}\n\n{options_text}"
+        chat_history[-1]["content"] = full_message
+
+        status_text = _format_status_panel(gs)
+        btn_updates = _get_button_updates(fallback_options)
+
+        yield (
+            chat_history, status_text,
+            btn_updates[0], btn_updates[1], btn_updates[2],
+            game_session,
+        )
+        return
+
 
 # ============================================================
 # UI 辅助函数
 # ============================================================
 
 
+# 兜底默认选项（当解析出的选项不足 3 个时使用）
+_FALLBACK_BUTTON_OPTIONS = [
+    {"id": 1, "text": "查看周围", "action_type": "EXPLORE"},
+    {"id": 2, "text": "等待一会", "action_type": "REST"},
+    {"id": 3, "text": "检查状态", "action_type": "EXPLORE"},
+]
+
+
+def _ensure_min_options(options: list[dict], min_count: int = 3) -> list[dict]:
+    """
+    强制确保选项列表至少有 min_count 个选项。
+    不足时用通用兜底选项补全，作为 UI 层的最终安全网。
+    """
+    if not isinstance(options, list):
+        options = []
+
+    if len(options) >= min_count:
+        return options[:min_count]
+
+    # 用兜底选项补全
+    for fb in _FALLBACK_BUTTON_OPTIONS:
+        if len(options) >= min_count:
+            break
+        if not any(o.get("text") == fb["text"] for o in options):
+            options.append(fb.copy())
+
+    # 极端兜底：仍不足则用"继续探索"填充
+    while len(options) < min_count:
+        options.append({
+            "id": len(options) + 1,
+            "text": "继续探索",
+            "action_type": "EXPLORE",
+        })
+
+    # 重新编号
+    for i, opt in enumerate(options[:min_count], 1):
+        if isinstance(opt, dict):
+            opt["id"] = i
+
+    return options[:min_count]
+
+
 def _format_options(options: list[dict]) -> str:
-    """将选项列表格式化为可读的文本"""
+    """将选项列表格式化为可读的文本（纯文字，绝不显示 JSON）"""
     if not options:
         return ""
     lines = ["---", "**你的选择：**"]
-    for opt in options:
-        idx = opt.get("id", "?")
-        text = opt.get("text", "未知选项")
+    for i, opt in enumerate(options):
+        # 安全提取：兼容 dict 和异常情况
+        if isinstance(opt, dict):
+            idx = opt.get("id", i + 1)
+            text = opt.get("text", "未知选项")
+        else:
+            idx = i + 1
+            text = str(opt)
         lines.append(f"  **[{idx}]** {text}")
     return "\n".join(lines)
 
 
+def _get_loading_button_updates() -> list:
+    """返回 3 个加载中占位按钮更新（始终可见，但禁用交互）"""
+    return [
+        gr.update(value="...", visible=True, interactive=False),
+        gr.update(value="...", visible=True, interactive=False),
+        gr.update(value="...", visible=True, interactive=False),
+    ]
+
+
 def _get_button_updates(options: list[dict]) -> list:
-    """从选项列表生成按钮的 gr.update() 对象（静态按钮 + 动态更新模式）"""
+    """从选项列表生成按钮的 gr.update() 对象，始终返回恰好 3 个更新"""
+    # 确保 options 是列表
+    if not isinstance(options, list):
+        options = []
+
+    # ★ 安全兜底：强制补全到 3 个选项，确保按钮永远是 3 个
+    options = _ensure_min_options(options, 3)
+
     updates = []
     for i in range(3):
-        if i < len(options):
-            text = options[i].get("text", "...")
-            updates.append(gr.update(value=text, visible=True, interactive=True))
+        opt = options[i]
+        if isinstance(opt, dict):
+            text = opt.get("text", "...")
         else:
-            updates.append(gr.update(value="", visible=False, interactive=False))
+            text = str(opt) if opt else "..."
+        updates.append(gr.update(value=text, visible=True, interactive=True))
     return updates
 
 
@@ -464,7 +698,7 @@ def build_app() -> gr.Blocks:
             # ==================
             # 左侧：聊天区域
             # ==================
-            with gr.Column(scale=3):
+            with gr.Column(scale=10):
                 # 玩家姓名输入 + 开始按钮
                 with gr.Row():
                     player_name_input = gr.Textbox(
@@ -476,12 +710,12 @@ def build_app() -> gr.Blocks:
                     start_btn = gr.Button(
                         "开始冒险",
                         variant="primary",
-                        scale=1,
+                        scale=2,
                     )
                     restart_btn = gr.Button(
                         "重启冒险",
                         variant="stop",
-                        scale=1,
+                        scale=2,
                     )
 
                 # 聊天窗口
@@ -490,16 +724,16 @@ def build_app() -> gr.Blocks:
                     height=480,
                 )
 
-                # 选项按钮
+                # 选项按钮（始终可见，加载时显示占位符）
                 with gr.Row():
                     option_btn_1 = gr.Button(
-                        "选项 1", visible=False
+                        "...", visible=True, interactive=False
                     )
                     option_btn_2 = gr.Button(
-                        "选项 2", visible=False
+                        "...", visible=True, interactive=False
                     )
                     option_btn_3 = gr.Button(
-                        "选项 3", visible=False
+                        "...", visible=True, interactive=False
                     )
 
                 # 自由输入
@@ -507,7 +741,7 @@ def build_app() -> gr.Blocks:
                     user_input = gr.Textbox(
                         label="自由输入（也可以直接点击上方选项）",
                         placeholder="输入你想做的事情，例如：和村长说话、攻击哥布林、搜索这个区域...",
-                        scale=4,
+                        scale=5,
                         interactive=False,
                     )
                     send_btn = gr.Button("发送", variant="primary", scale=1)
@@ -515,7 +749,7 @@ def build_app() -> gr.Blocks:
             # ==================
             # 右侧：状态面板
             # ==================
-            with gr.Column(scale=1):
+            with gr.Column(scale=2, min_width=250):
                 status_panel = gr.Markdown(
                     value="## 等待开始...\n\n请输入角色名称并点击「开始冒险」",
                     label="角色状态",
@@ -575,9 +809,19 @@ def build_app() -> gr.Blocks:
             outputs=[user_input],
         )
 
-        # 选项按钮点击
+        # 选项按钮点击（需要使用 yield from 的生成器包装函数，
+        # 使 Gradio 能正确识别为流式输出）
+        def _option_click_0(ch, gs):
+            yield from process_option_click(0, ch, gs)
+
+        def _option_click_1(ch, gs):
+            yield from process_option_click(1, ch, gs)
+
+        def _option_click_2(ch, gs):
+            yield from process_option_click(2, ch, gs)
+
         option_btn_1.click(
-            fn=lambda ch, gs: process_option_click(0, ch, gs),
+            fn=_option_click_0,
             inputs=[chatbot, game_session],
             outputs=[
                 chatbot, status_panel,
@@ -587,7 +831,7 @@ def build_app() -> gr.Blocks:
         )
 
         option_btn_2.click(
-            fn=lambda ch, gs: process_option_click(1, ch, gs),
+            fn=_option_click_1,
             inputs=[chatbot, game_session],
             outputs=[
                 chatbot, status_panel,
@@ -597,7 +841,7 @@ def build_app() -> gr.Blocks:
         )
 
         option_btn_3.click(
-            fn=lambda ch, gs: process_option_click(2, ch, gs),
+            fn=_option_click_2,
             inputs=[chatbot, game_session],
             outputs=[
                 chatbot, status_panel,

state_manager.py

@@ -757,14 +757,32 @@ class GameState:
                     self.world.locations[new_loc].is_discovered = True
 
         # --- 物品变更 ---
+        # 货币关键词列表：这些物品不进背包，而是直接转换为金币
+        _CURRENCY_KEYWORDS = ["铜币", "银币", "铜钱", "银两", "金币", "货币", "钱袋", "钱币", "硬币"]
+
         if "items_gained" in changes:
             for item in changes["items_gained"]:
-                self.player.inventory.append(str(item))
+                item_str = str(item)
+                # 检查是否为货币类物品 —— 如果是，跳过入背包（金币已通过 gold_change 处理）
+                is_currency = any(kw in item_str for kw in _CURRENCY_KEYWORDS)
+                if is_currency:
+                    # 如果 gold_change 没有设置，尝试自动补偿少量金币
+                    if "gold_change" not in changes:
+                        old_gold = self.player.gold
+                        self.player.gold += 3  # 默认少量金币
+                        change_log.append(f"金币: {old_gold} → {self.player.gold}")
+                    logger.info(f"货币物品 '{item_str}' 已转换为金币，不放入背包")
+                    continue
+                self.player.inventory.append(item_str)
                 change_log.append(f"获得物品: {item}")
 
         if "items_lost" in changes:
             for item in changes["items_lost"]:
                 item_str = str(item)
+                # 货币类物品也不需要从背包移除
+                is_currency = any(kw in item_str for kw in _CURRENCY_KEYWORDS)
+                if is_currency:
+                    continue
                 if item_str in self.player.inventory:
                     self.player.inventory.remove(item_str)
                     change_log.append(f"失去物品: {item}")
@@ -901,8 +919,25 @@ class GameState:
             for slot, item_name in changes["equip"].items():
                 if slot in self.player.equipment:
                     old_item = self.player.equipment[slot]
-                    self.player.equipment[slot] = item_name
-                    change_log.append(f"装备 [{slot}]: {old_item} → {item_name}")
+                    new_item = item_name if item_name and str(item_name).lower() not in ("none", "null", "") else None
+
+                    # 1. 如果旧装备栏有物品，卸下时放回背包
+                    if old_item and old_item != "无":
+                        if old_item not in self.player.inventory:
+                            self.player.inventory.append(old_item)
+                            logger.info(f"卸下装备 '{old_item}' 放回背包")
+
+                    # 2. 如果要装备新物品，从背包中移除
+                    if new_item:
+                        new_item_str = str(new_item)
+                        if new_item_str in self.player.inventory:
+                            self.player.inventory.remove(new_item_str)
+                            logger.info(f"从背包取出 '{new_item_str}' 装备到 [{slot}]")
+
+                    self.player.equipment[slot] = new_item
+                    display_old = old_item or "无"
+                    display_new = new_item or "无"
+                    change_log.append(f"装备 [{slot}]: {display_old} → {display_new}")
 
         # --- 玩家称号变更 ---
         if "title_change" in changes:
@@ -1091,7 +1126,14 @@ class GameState:
             "非消耗品（哨子、武器、工具、乐器、钥匙等可重复使用的物品）使用后仍然保留在背包中，"
             "绝对不要将它们放入 items_lost。例如：吹响哨子后哨子仍在背包中；使用火把照明后火把仍在。\n"
             "10. 【选项物品约束】生成的选项中如果涉及使用某个物品，该物品必须当前在玩家背包中。"
-            "不要生成使用玩家不拥有的物品的选项。"
+            "不要生成使用玩家不拥有的物品的选项。\n"
+            '11. 【货币规则】游戏内货币统一为"金币"，对应 gold_change 字段。严禁使用"铜币""银币""银两"等名称。'
+            "任何钱财/财物类收获（如击败怪物掉落的钱币、交易获得的货款等）必须通过 gold_change 表达，"
+            "严禁将任何种类的钱币放入 items_gained。\n"
+            '12. 【装备规则】装备物品时必须使用 equip 字段指定槽位和物品名称（如 "weapon": "小刀"）。'
+            "系统会自动将装备的物品从背包移到装备栏，并将旧装备放回背包。"
+            "因此装备操作时不要在 items_lost/items_gained 中重复处理该物品。"
+            "合法槽位：weapon / armor / accessory / helmet / boots。卸下装备时将对应槽位设为 null。"
         )
 
         # 组合完整 Prompt

story_engine.py

@@ -20,7 +20,7 @@ import logging
 import re
 from typing import Optional
 
-from utils import call_qwen, safe_json_call, extract_json_from_text, DEFAULT_MODEL
+from utils import call_qwen, call_qwen_stream, safe_json_call, extract_json_from_text, DEFAULT_MODEL
 from state_manager import GameState
 
 logger = logging.getLogger("StoryWeaver")
@@ -84,6 +84,24 @@ def _merge_change_logs(tick_log: list[str], action_log: list[str]) -> list[str]:
     return remaining_tick + merged_results
 
 
+def _normalize_markers(text: str) -> str:
+    """
+    标准化 LLM 输出中的分隔标记，处理常见变体格式。
+
+    LLM 有时会输出与预期略有不同的标记格式，例如：
+    - 多余的空格: "--- STORY_TEXT ---"
+    - 不同的连字符数量: "----STORY_TEXT----"
+    - 大小写变化: "---story_text---"
+    - 下划线变空格: "---STORY TEXT---"
+    此函数将这些变体统一为标准格式。
+    """
+    text = re.sub(r'-{2,}\s*STORY[_ ]?TEXT\s*-{2,}', '---STORY_TEXT---', text, flags=re.IGNORECASE)
+    text = re.sub(r'-{2,}\s*OPTIONS[_ ]?JSON\s*-{2,}', '---OPTIONS_JSON---', text, flags=re.IGNORECASE)
+    text = re.sub(r'-{2,}\s*STATE[_ ]?JSON\s*-{2,}', '---STATE_JSON---', text, flags=re.IGNORECASE)
+    text = re.sub(r'-{2,}\s*THINKING\s*-{2,}', '---THINKING---', text, flags=re.IGNORECASE)
+    return text
+
+
 # ============================================================
 # Prompt 模板设计
 # ============================================================
@@ -153,7 +171,8 @@ OUTLINE_SYSTEM_PROMPT_TEMPLATE = """你是一个专业的 RPG 叙事引擎的规
 - 确保所有数值变更合理（例如战斗伤害应考虑攻防差值）
 - 【关键】所有数值变更必须精确，禁止使用“恢复一些”“大幅降低”等模糊描述，必须给出精确数字（如 hunger_change: 14）。
 - 【关键】time_change 字段只允许以下值之一："清晨""上午""正午""下午""黄昏""夜晚""深夜"，不要填写其他格式（如"30分钟""两小时后"等都是非法值）。如果本回合没有发生时间跳跃（例如休息、等待、长途旅行等），请设为 null（系统会自动推进一个时段）。只有当剧情需要跳跃多个时段时才设置此字段。
-- 【关键】游戏内的货币单位是"金币"，对应 gold_change 字段。不要使用"银币""铜币""银两"等其他货币名称，所有交易都以"金币"结算。
+- 【关键】游戏内的货币单位统一为"金币"，对应 gold_change 字段。严禁使用"银币""铜币""银两""钱币"等其他货币名称。任何财物/钱财类收获必须通过 gold_change 字段表达，严禁将钱币放入 items_gained。举例：击败怪物掉落 3 金币 → gold_change: 3，绝对不要在 items_gained 中放入"铜币""银币""金币"等。
+- 【关键 —— 装备规则】当玩家装备某个物品时，必须在 equip 字段中指定对应槽位和物品名称（如 "weapon": "小刀"）。系统会自动将装备的物品从背包移到装备栏，并将替换下来的旧装备放回背包。因此装备操作时不要在 items_lost/items_gained 中重复处理该物品。合法槽位：weapon / armor / accessory / helmet / boots。卸下装备时将对应槽位设为 null。
 - 【关键】status_effects_added 中每个效果必须是一个对象，且必须包含以下字段：
     - "name": 中文效果名称（如"中毒""祝福""饱腹"），必须是中文，不要使用英文字段名
     - "description": 获得原因的简短说明（如"食用面包后精力充沛""被毒蛇咬伤"）
@@ -184,7 +203,15 @@ OUTLINE_SYSTEM_PROMPT_TEMPLATE = """你是一个专业的 RPG 叙事引擎的规
 # - 选项应覆盖不同策略（如激进/保守/探索）
 # - 中等温度 (0.8) 增加文学创意
 # ------------------------------------------------------------
-NARRATIVE_SYSTEM_PROMPT_TEMPLATE = """你是一个经验丰富的奇幻小说家，正在为一个互动 RPG 游戏编写剧情文本。
+NARRATIVE_SYSTEM_PROMPT_TEMPLATE = """【最高优先级指令 ── 输出格式】
+你的输出必须严格遵守以下格式，这是最高优先级的要求，违反将导致系统崩溃：
+1. 先输出 ---STORY_TEXT--- 标记（独占一行）
+2. 然后直接写故事内容，不加任何前缀（禁止“好的”“以下是”等）
+3. 故事写完后输出 ---OPTIONS_JSON--- 标记（独占一行）
+4. 最后输出 JSON 格式的 3 个选项数组
+绝对不要省略这两个标记。
+
+你是一个经验丰富的奇幻小说家，正在为一个互动 RPG 游戏编写剧情文本。
 
 {world_state}
 
@@ -253,7 +280,15 @@ DEATH_NARRATIVE_PROMPT = """你是一个才华横溢的奇幻小说家。玩家
 # ------------------------------------------------------------
 # 开场叙事 Prompt
 # ------------------------------------------------------------
-OPENING_NARRATIVE_PROMPT = """你是一个经验丰富的奇幻小说家，正在为一个互动 RPG 游戏编写开场白。
+OPENING_NARRATIVE_PROMPT = """【��高优先级指令 ── 输出格式】
+你的输出必须严格遵守以下格式，这是最高优先级的要求，违反将导致系统崩溃：
+1. 先输出 ---STORY_TEXT--- 标记（独占一行）
+2. 然后直接写故事内容（200-400字），不加任何前缀（禁止“好的”“以下是”等）
+3. 故事写完后输出 ---OPTIONS_JSON--- 标记（独占一行）
+4. 最后输出 JSON 格式的 3 个选项数组
+绝对不要省略这两个标记。
+
+你是一个经验丰富的奇幻小说家，正在为一个互动 RPG 游戏编写开场白。
 
 {world_state}
 
@@ -278,6 +313,101 @@ OPENING_NARRATIVE_PROMPT = """你是一个经验丰富的奇幻小说家，正
 """
 
 
+# ------------------------------------------------------------
+# 合并式 Prompt：一次调用完成大纲 + 叙事 + 选项
+#
+# 设计思路：
+# - 将两阶段生成合并为一次 API 调用，减少一半延迟
+# - THINKING 区域供模型内部规划（不展示给玩家），确保一致性
+# - STORY_TEXT 区域放在中间，支持流式输出（用户最先看到文字）
+# - STATE_JSON 和 OPTIONS_JSON 放在末尾，供程序解析
+# ------------------------------------------------------------
+MERGED_SYSTEM_PROMPT_TEMPLATE = """【最高优先级指令 ── 输出格式】
+你的输出必须严格遵守以下分隔标记格式。这是最高优先级的要求，违反将导致系统崩溃：
+- ---THINKING--- （规划区域）
+- ---STORY_TEXT--- （故事文本，200-400字，不加任何前缀）
+- ---STATE_JSON--- （状态变更 JSON）
+- ---OPTIONS_JSON--- （3 个选项的 JSON 数组）
+每个区域必须以对应的 --- 标记开头（独占一行）。绝对不要省略任何标记。故事文本区域只放纯叙事文字，禁止混入 JSON。
+
+你是一个专业的 RPG 叙事引擎，兼具剧情规划与文学描写能力。
+
+{world_state}
+
+【你的任务】
+根据玩家的行动意图，在一次输出中完成以下所有工作：
+1. 在 THINKING 标签内进行简短的剧情规划（不展示给玩家）
+2. 写一段 200-400 字的剧情描写
+3. 输出结构化的状态变更 JSON
+4. 生成 3 个后续选项
+
+【状态变更规则】
+- 只填写确实发生变化的字段，未变化的设为 null/0/空或省略
+- 所有数值变更必须精确，禁止模糊描述如"恢复一些"
+- time_change 仅允许："清晨""上午""正午""下午""黄昏""夜晚""深夜"，无跳跃则 null
+- 货币统一为"金币"（gold_change），严禁使用"铜币""银币""银两"等。任何钱财收获只通过 gold_change 表达，严禁将钱币放入 items_gained
+- 装备规则：装备物品时用 equip 字段指定槽位和物品名（如 "weapon": "小刀"），系统自动处理背包⇌装备栏转移。装备时不要在 items_lost/items_gained 重复处理该物品。合法槽位：weapon/armor/accessory/helmet/boots。卸下装备设槽位为 null
+- status_effects_added 中每个效果须含：name/description/effect_type/stat_modifiers/duration
+- 数值不超合法范围（HP∈[0,max_hp]，饱食度/士气/理智∈[0,100]）
+- new_location/weather_change/title_change/world_event 仅真正变化时填写，否则 null
+- quest_updates.status 只允许 "active"/"completed"/"failed"
+- 消耗品（药水、食物等一次性物品）使用后放入 items_lost；非消耗品（武器、工具等）使用后不放入 items_lost
+- 仅重要事件才添加状态效果，普通日常行为不产生
+- npc_changes 格式: {{"NPC名称": {{"attitude": "新态度", "relationship_change": 数值, "memory_add": "新记忆", "hp_change": 数值}}}}
+- quest_updates 格式: {{"任务ID": {{"objectives_completed": ["完成的目标"], "status": "新状态"}}}}
+
+【叙事写作规则】
+- 使用第二人称"你"叙述
+- 文本开头必须直接回应玩家的行动/选择
+- 文风简洁自然有画面感，像写小说而非诗歌
+- 多用具体动作和对话，少用比喻修辞
+- 禁用："阳光洒下""微风拂过""空气中弥漫着""如同XX般"
+- 严禁重复相似的动作描写（如"握紧拳头""深吸一口气"等不可每回合重复）
+- NPC 首次出场需先描写外貌/特征，再自然引出名字
+- 战斗场景要紧张刺激
+- 货币统一称"金币"
+
+【选项规则】
+- 恰好 3 个选项，覆盖不同策略方向（激进/谨慎/探索/社交等）
+- 选项中的人物/物品/地点必须已在当前或之前剧情中出现过
+- 获得新物品时至少一个选项涉及使用该物品
+- 使用物品的选项中该物品必须在背包中
+
+【输出格式（严格遵守，按以下顺序输出）】
+
+---THINKING---
+（简短剧情规划：事件类型、涉及NPC、关键状态变更概要，3-5句话即可）
+
+---STORY_TEXT---
+（200-400 字剧情描写）
+
+---STATE_JSON---
+{{
+    "event_summary": "一句话描述",
+    "event_type": "COMBAT/DIALOGUE/MOVE/ITEM/QUEST/TRADE/REST/DISCOVERY",
+    "involved_npcs": [],
+    "state_changes": {{
+        "hp_change": 0, "mp_change": 0, "gold_change": 0, "exp_change": 0,
+        "morale_change": 0, "sanity_change": 0, "hunger_change": 0, "karma_change": 0,
+        "new_location": null, "items_gained": [], "items_lost": [],
+        "skills_gained": [], "status_effects_added": [], "status_effects_removed": [],
+        "npc_changes": {{}}, "quest_updates": {{}},
+        "weather_change": null, "time_change": null, "global_flags_set": {{}},
+        "world_event": null, "equip": {{}}, "title_change": null
+    }},
+    "consequence_tags": [],
+    "is_reversible": true
+}}
+
+---OPTIONS_JSON---
+[
+    {{"id": 1, "text": "选项描述", "action_type": "动作类型（ATTACK/TALK/MOVE/EXPLORE/USE_ITEM等）"}},
+    {{"id": 2, "text": "选项描述", "action_type": "动作类型"}},
+    {{"id": 3, "text": "选项描述", "action_type": "动作类型"}}
+]
+"""
+
+
 class StoryEngine:
     """
     叙事引擎 —— 负责故事内容的生成
@@ -583,54 +713,147 @@ class StoryEngine:
             "consistency_issues": [],
         }
 
+    @staticmethod
+    def _clean_story_text(story_text: str) -> str:
+        """
+        清理故事文本中残留的 JSON 选项数组和格式标记。
+
+        LLM 有时会将选项 JSON 嵌入到故事文本中（尤其在标记之间），
+        此方法移除这些 JSON 片段，仅保留纯叙事文本。
+        """
+        # 移除看起来像选项 JSON 数组的内容: [{"id": ...}, ...]
+        cleaned = re.sub(
+            r'\[\s*\{\s*"id"\s*:.*?\]',
+            '',
+            story_text,
+            flags=re.DOTALL,
+        )
+        # 移除残留的标记
+        for marker in ["---STORY_TEXT---", "---OPTIONS_JSON---", "---STATE_JSON---", "---THINKING---"]:
+            cleaned = cleaned.replace(marker, "")
+        # 移除可能因清理产生的多余空行（保留最多一个空行）
+        cleaned = re.sub(r'\n{3,}', '\n\n', cleaned)
+        return cleaned.strip()
+
     def _parse_story_response(self, raw_text: str) -> tuple[str, list[dict]]:
         """
         解析 LLM 返回的故事响应，分离文本和选项。
 
-        预期格式：
-        ---STORY_TEXT---
-        (故事文本)
-        ---OPTIONS_JSON---
-        [JSON 选项数组]
-
-        降级策略：如果格式不符，尝试直接提取 JSON 数组。
+        采用 **暴力提取策略**：
+        1. 优先尝试标准标记格式
+        2. 如都失败，默认将整段文本视为故事文本
+        3. 从末尾向前查找 JSON 块 ([...] 或 {...})，若找到则切除并解析为选项
+        4. 找不到任何 JSON 则整段当故事 + 硬性默认选项
         """
+        # ★ 调试日志
+        logger.debug(f"原始 API 返回内容: {raw_text}")
+
         story_text = ""
         options = []
 
-        if "---STORY_TEXT---" in raw_text and "---OPTIONS_JSON---" in raw_text:
-            # 标准格式解析：严格取两个标记之间的内容，避免LLM在标记前重复输出导致文本重复
-            story_start = raw_text.index("---STORY_TEXT---") + len("---STORY_TEXT---")
-            options_start = raw_text.index("---OPTIONS_JSON---")
-            story_part = raw_text[story_start:options_start].strip()
-            options_part = raw_text[options_start + len("---OPTIONS_JSON---"):].strip()
+        if not raw_text or not raw_text.strip():
+            logger.warning("API 返回内容为空")
+            return "你环顾四周，思考着接下来该做什么...", self._generate_default_options()
+
+        # 标准化标记格式
+        normalized = _normalize_markers(raw_text)
+
+        # ========== 策略 1：标准标记格式 ==========
+        if "---STORY_TEXT---" in normalized and "---OPTIONS_JSON---" in normalized:
+            story_start = normalized.index("---STORY_TEXT---") + len("---STORY_TEXT---")
+            options_start = normalized.index("---OPTIONS_JSON---")
+            story_part = normalized[story_start:options_start].strip()
+            options_part = normalized[options_start + len("---OPTIONS_JSON---"):].strip()
 
             story_text = story_part
             parsed_options = extract_json_from_text(options_part)
-            if isinstance(parsed_options, list):
+            if isinstance(parsed_options, list) and len(parsed_options) > 0:
                 options = parsed_options
-        else:
-            # 降级：尝试找到 JSON 数组作为选项
-            logger.warning("响应格式不标准，尝试降级解析")
-            # 查找最后出现的 JSON 数组
-            import re
-            array_matches = list(re.finditer(r"\[[\s\S]*?\]", raw_text))
-            if array_matches:
-                last_match = array_matches[-1]
-                options_text = last_match.group()
-                parsed = extract_json_from_text(options_text)
-                if isinstance(parsed, list):
-                    options = parsed
-                    story_text = raw_text[:last_match.start()].strip()
-                else:
-                    story_text = raw_text
-            else:
-                story_text = raw_text
+                logger.info("标准格式解析成功")
+        # ========== 策略 1b：只有 STORY_TEXT 没有 OPTIONS_JSON ==========
+        elif "---STORY_TEXT---" in normalized:
+            logger.warning("找到 STORY_TEXT 标记但缺少 OPTIONS_JSON，暴力提取")
+            story_start = normalized.index("---STORY_TEXT---") + len("---STORY_TEXT---")
+            remaining = normalized[story_start:].strip()
+            # 从 remaining 末尾查找 JSON
+            story_text, options = self._brute_force_extract(remaining)
+
+        # ========== 策略 2：完全没有标记 → 暴力提取 ==========
+        if not story_text.strip():
+            logger.warning("响应格式不标准，使用暴力提取策略")
+            story_text, options = self._brute_force_extract(normalized)
+
+        # 清理 story_text 中可能残留的 JSON 和标记
+        story_text = self._clean_story_text(story_text)
+
+        # 移除常见的 AI 前缀
+        story_text = re.sub(r'^(好的[，,]?\s*(这是|以下是|下面是).*?[：:]\s*)', '', story_text, flags=re.MULTILINE)
+
+        # 如果 story_text 仍为空，使用兜底文本
+        if not story_text.strip():
+            logger.warning("解析后 story_text 为空，使用兜底文本")
+            story_text = "你环顾四周，思考着接下来该做什么..."
 
         # 确保至少有默认选项
         if not options:
+            logger.info("未提取到有效选项，使用默认选项")
             options = self._generate_default_options()
 
+        # 确保恰好 3 个选项
+        options = self._ensure_three_options(options)
+
+        return story_text, options
+
+    def _brute_force_extract(self, text: str) -> tuple[str, list[dict]]:
+        """
+        暴力提取策略：默认整段文本都是故事，从末尾向前查找 JSON 块并切除。
+
+        Args:
+            text: 待解析的文本
+
+        Returns:
+            (story_text, options_list)
+        """
+        options = []
+        story_text = text
+
+        # 第一步：尝试从末尾向前找 JSON 数组 [...]
+        json_array_matches = list(re.finditer(r'\[\s*\{.*?\}\s*\]', text, re.DOTALL))
+        if json_array_matches:
+            last_match = json_array_matches[-1]
+            try:
+                parsed = extract_json_from_text(last_match.group())
+                if isinstance(parsed, list) and len(parsed) > 0:
+                    # 检查是否看起来像选项（至少一个元素有 text 或 id 字段）
+                    if any(isinstance(item, dict) and ("text" in item or "id" in item) for item in parsed):
+                        options = parsed
+                        story_text = text[:last_match.start()].strip()
+                        logger.info(f"暴力提取：从末尾找到 JSON 数组，提取了 {len(options)} 个选项")
+            except Exception:
+                pass
+
+        # 第二步：如果没找到数组，尝试找独立的 JSON 对象 {...}
+        if not options:
+            json_obj_matches = list(re.finditer(r'\{[^{}]*"(?:text|id|action_type)"[^{}]*\}', text, re.DOTALL))
+            if json_obj_matches and len(json_obj_matches) >= 2:
+                first_match_start = json_obj_matches[0].start()
+                last_match_end = json_obj_matches[-1].end()
+                json_block = text[first_match_start:last_match_end]
+                wrapped = "[" + json_block + "]"
+                try:
+                    parsed = extract_json_from_text(wrapped)
+                    if isinstance(parsed, list) and len(parsed) > 0:
+                        options = parsed
+                        story_text = text[:first_match_start].strip()
+                        logger.info(f"暴力提取：通过独立 JSON 对象拼合，提取了 {len(options)} 个选项")
+                except Exception:
+                    pass
+
+        # 第三步：完全没有 JSON 影子 → 整段当故事
+        if not options:
+            logger.info("暴力提取：未发现任何 JSON，整段文本作为故事，使用默认选项")
+            story_text = text
+
         return story_text, options
 
     def _generate_default_options(self) -> list[dict]:
@@ -663,6 +886,34 @@ class StoryEngine:
 
         return default_options[:3]
 
+    def _ensure_three_options(self, options: list[dict]) -> list[dict]:
+        """
+        确保恰好有 3 个选项，不足时用默认选项补齐。
+
+        LLM 有时只生成 2 个甚至 1 个选项，此方法确保 UI 始终显示 3 个按钮。
+        """
+        if len(options) >= 3:
+            options = options[:3]
+        else:
+            defaults = self._generate_default_options()
+            for d in defaults:
+                if len(options) >= 3:
+                    break
+                # 避免重复选项
+                if not any(o.get("text") == d["text"] for o in options):
+                    options.append(d)
+            # 兜底：如果仍不足 3 个，补充通用选项
+            while len(options) < 3:
+                options.append({
+                    "id": len(options) + 1,
+                    "text": "继续探索",
+                    "action_type": "EXPLORE",
+                })
+        # 重新编号
+        for i, opt in enumerate(options[:3], 1):
+            opt["id"] = i
+        return options[:3]
+
     def _fallback_response(self, player_intent: dict, tick_log: list[str] | None = None) -> dict:
         """
         降级响应：当大纲生成完全失败时，提供基本响应。
@@ -814,22 +1065,8 @@ class StoryEngine:
             if is_valid:
                 validated.append(opt)
 
-        # 确保仍然有 3 个选项
-        if len(validated) < 3:
-            defaults = self._generate_default_options()
-            for d in defaults:
-                if len(validated) >= 3:
-                    break
-                # 避免重复选项
-                if not any(v.get("text") == d["text"] for v in validated):
-                    d["id"] = len(validated) + 1
-                    validated.append(d)
-
-        # 重新编号
-        for i, opt in enumerate(validated[:3], 1):
-            opt["id"] = i
-
-        return validated[:3]
+        # 确保恰好 3 个选项
+        return self._ensure_three_options(validated)
 
     def process_option_selection(self, option: dict) -> dict:
         """
@@ -850,3 +1087,379 @@ class StoryEngine:
             "raw_input": option.get("text", ""),
         }
         return self.generate_story(intent)
+
+    # ============================================================
+    # 流式输出 + 合并式生成（核心优化）
+    # ============================================================
+
+    def generate_opening_stream(self):
+        """
+        流式生成游戏开场叙事。
+
+        ★ 重要设计：流式循环中仅做文本展示（story_chunk），
+        选项解析逻辑严格在整个数据流结束后才执行一次。
+
+        Yields:
+            {"type": "story_chunk", "text": "累积的故事文本"}  — 流式文本更新
+            {"type": "final", ...}  — 最终完整结果（包含必定 3 个选项）
+        """
+        logger.info("[流式] 生成游戏开场叙事...")
+
+        prompt = OPENING_NARRATIVE_PROMPT.format(
+            world_state=self.game_state.to_prompt(),
+            player_name=self.game_state.player.name,
+        )
+
+        messages = [
+            {"role": "system", "content": prompt},
+            {"role": "user", "content": "请开始讲述故事的开场。"},
+        ]
+
+        full_text = ""
+        story_started = False
+        story_ended = False
+
+        try:
+            for chunk in call_qwen_stream(messages, model=self.model, temperature=0.9, max_tokens=2000):
+                full_text += chunk
+
+                # ★ 流式循环中只做展示用途的标记检测，绝不在此处解析选项
+                normalized = _normalize_markers(full_text)
+
+                if not story_started:
+                    if "---STORY_TEXT---" in normalized:
+                        story_started = True
+                        idx = normalized.index("---STORY_TEXT---") + len("---STORY_TEXT---")
+                        current_story = normalized[idx:]
+                        if "---OPTIONS_JSON---" in current_story:
+                            story_ended = True
+                            current_story = current_story[:current_story.index("---OPTIONS_JSON---")]
+                        display_text = self._clean_story_text(current_story)
+                        if display_text.strip():
+                            yield {"type": "story_chunk", "text": display_text.strip()}
+                elif not story_ended:
+                    idx = normalized.index("---STORY_TEXT---") + len("---STORY_TEXT---")
+                    current_story = normalized[idx:]
+                    if "---OPTIONS_JSON---" in current_story:
+                        story_ended = True
+                        current_story = current_story[:current_story.index("---OPTIONS_JSON---")]
+                    display_text = self._clean_story_text(current_story)
+                    if display_text.strip():
+                        yield {"type": "story_chunk", "text": display_text.strip()}
+
+        except Exception as e:
+            logger.error(f"流式开场生成失败: {e}，降级为非流式")
+            try:
+                result = self.generate_opening()
+                # 降级结果也强制保证 3 个选项
+                result["options"] = self._ensure_three_options(result.get("options", []))
+                yield {"type": "final", **result}
+            except Exception:
+                yield {
+                    "type": "final",
+                    "story_text": "你踏上了一段新的旅程...",
+                    "options": self._generate_default_options(),
+                    "state_changes": {},
+                    "change_log": [],
+                }
+            return
+
+        # ★ 如果流式阶段未检测到标记但有累积文本，先 yield 给 UI 显示
+        if not story_started and full_text.strip():
+            logger.warning("流式阶段未检测到 STORY_TEXT 标记，直接使用累积文本")
+            # 清理后先 yield 给 UI，确保用户能看到文本
+            display = self._clean_story_text(full_text.strip())
+            display = re.sub(r'^(好的[，,]?\s*(这是|以下是|下面是).*?[：:]\s*)', '', display, flags=re.MULTILINE)
+            if display.strip():
+                yield {"type": "story_chunk", "text": display.strip()}
+
+        # ★ 核心：只在数据流完全结束后，用完整 full_text 解析（暴力提取策略）
+        story_text, options = self._parse_story_response(full_text)
+
+        # ★ 双重保险：确保恰好 3 个选项
+        options = self._ensure_three_options(options)
+
+        logger.info(f"[流式开场] 最终 story_text 长度={len(story_text)}, 选项数={len(options)}")
+
+        yield {
+            "type": "final",
+            "story_text": story_text,
+            "options": options,
+            "state_changes": {},
+            "change_log": [],
+        }
+
+    def generate_story_stream(self, player_intent: dict):
+        """
+        流式生成故事响应（合并大纲+叙事为一次 API 调用）。
+
+        使用 MERGED_SYSTEM_PROMPT_TEMPLATE，一次调用完成：
+        - 内部规划（THINKING 区域，不展示）
+        - 故事文本（STORY_TEXT 区域，流式展示）
+        - 状态变更（STATE_JSON 区域，程序解析）
+        - 选项（OPTIONS_JSON 区域，程序解析）
+
+        Yields:
+            {"type": "story_chunk", "text": "累积的故事文本"}
+            {"type": "final", "story_text": ..., "options": ..., ...}
+        """
+        logger.info(f"[流式/合并] 生成故事响应，玩家意图: {player_intent}")
+
+        # 推进时间
+        tick_log = self.game_state.tick_time()
+
+        # 构建合并 Prompt
+        system_prompt = MERGED_SYSTEM_PROMPT_TEMPLATE.format(
+            world_state=self.game_state.to_prompt(),
+        )
+
+        user_message = (
+            f"玩家行动: {player_intent.get('raw_input', '未知行动')}\n"
+            f"解析意图: {player_intent.get('intent', 'UNKNOWN')}\n"
+            f"目标: {player_intent.get('target', '无')}\n"
+            f"细节: {player_intent.get('details', '无')}"
+        )
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_message},
+        ]
+
+        full_text = ""
+        story_started = False
+        story_ended = False
+
+        try:
+            for chunk in call_qwen_stream(messages, model=self.model, temperature=0.7, max_tokens=3000):
+                full_text += chunk
+
+                # 使用标准化标记检测，处理 LLM 输出的常见变体格式
+                normalized = _normalize_markers(full_text)
+
+                # 跳过 THINKING 区域，从 STORY_TEXT 开始流式输出
+                if not story_started:
+                    if "---STORY_TEXT---" in normalized:
+                        story_started = True
+                        idx = normalized.index("---STORY_TEXT---") + len("---STORY_TEXT---")
+                        current_story = normalized[idx:]
+                        # 检查是否已经到了 STATE_JSON
+                        if "---STATE_JSON---" in current_story:
+                            story_ended = True
+                            current_story = current_story[:current_story.index("---STATE_JSON---")]
+                        display_text = self._clean_story_text(current_story)
+                        if display_text.strip():
+                            yield {"type": "story_chunk", "text": display_text.strip()}
+                elif not story_ended:
+                    idx = normalized.index("---STORY_TEXT---") + len("---STORY_TEXT---")
+                    current_story = normalized[idx:]
+                    if "---STATE_JSON---" in current_story:
+                        story_ended = True
+                        current_story = current_story[:current_story.index("---STATE_JSON---")]
+                    display_text = self._clean_story_text(current_story)
+                    if display_text.strip():
+                        yield {"type": "story_chunk", "text": display_text.strip()}
+
+        except Exception as e:
+            logger.error(f"流式合并生成失败: {e}，降级为非流式两阶段")
+            try:
+                result = self.generate_story(player_intent)
+                # 降级结果也强制保证 3 个选项
+                result["options"] = self._ensure_three_options(result.get("options", []))
+                yield {"type": "final", **result}
+            except Exception:
+                fallback = self._fallback_response(player_intent, tick_log)
+                fallback["options"] = self._ensure_three_options(fallback.get("options", []))
+                yield {"type": "final", **fallback}
+            return
+
+        # ★ 如果流式阶段未检测到标记但有累积文本，先 yield 给 UI 显示
+        if not story_started and full_text.strip():
+            logger.warning("[流式合并] 未检测到 STORY_TEXT 标记，直接使用累积文本")
+            display = self._clean_story_text(full_text.strip())
+            display = re.sub(r'^(好的[，,]?\s*(这是|以下是|下面是).*?[：:]\s*)', '', display, flags=re.MULTILINE)
+            if display.strip():
+                yield {"type": "story_chunk", "text": display.strip()}
+
+        # 解析合并响应
+        outline, story_text, options = self._parse_merged_response(full_text)
+
+        if outline is None:
+            # ★ outline 为空不代表 story_text 也为空！
+            # 如果 story_text 已成功提取，继续走正常流程而非丢弃
+            if story_text and story_text.strip():
+                logger.warning("大纲(STATE_JSON)解析失败，但故事文本已提取，跳过状态更新继续")
+                options = self._ensure_three_options(options)
+                yield {
+                    "type": "final",
+                    "story_text": story_text,
+                    "options": options,
+                    "state_changes": {},
+                    "change_log": tick_log + ["（系统提示：本回合状态解析失败，未更新状态）"],
+                    "outline": None,
+                    "consistency_issues": [],
+                }
+                return
+            else:
+                logger.error("合并响应解析完全失败，使用降级")
+                fallback = self._fallback_response(player_intent, tick_log)
+                yield {"type": "final", **fallback}
+                return
+
+        # 处理时间冲突
+        state_changes = outline.get("state_changes", {})
+        if state_changes.get("time_change"):
+            tick_log = [line for line in tick_log if not line.startswith("时间流逝:")]
+
+        # 一致性检查
+        consistency_issues = self.game_state.check_consistency(state_changes)
+
+        if consistency_issues:
+            logger.warning(f"发现一致性问题: {consistency_issues}")
+
+        # 清理状态变更
+        event_type = outline.get("event_type", "")
+        state_changes, sanitize_warnings = self._sanitize_state_changes(state_changes, event_type)
+
+        # 应用状态变更
+        change_log = self.game_state.apply_changes(state_changes)
+
+        # 校验状态合法性
+        is_valid, validation_issues = self.game_state.validate()
+
+        # 记录事件
+        self.game_state.log_event(
+            event_type=outline.get("event_type", "UNKNOWN"),
+            description=outline.get("event_summary", ""),
+            player_action=player_intent.get("raw_input", ""),
+            involved_npcs=outline.get("involved_npcs", []),
+            state_changes=state_changes,
+            consequence_tags=outline.get("consequence_tags", []),
+            is_reversible=outline.get("is_reversible", True),
+        )
+
+        # 检查游戏结束
+        if self.game_state.is_game_over():
+            death_result = self._generate_death_narrative()
+            yield {"type": "final", **death_result}
+            return
+
+        # 验证选项
+        options = self._validate_options(options)
+
+        # ★ 双重保险：强制确保恰好 3 个选项
+        options = self._ensure_three_options(options)
+
+        # 合并日志
+        merged_log = _merge_change_logs(tick_log, change_log + validation_issues)
+
+        yield {
+            "type": "final",
+            "story_text": story_text,
+            "options": options,
+            "state_changes": state_changes,
+            "change_log": merged_log,
+            "outline": outline,
+            "consistency_issues": consistency_issues,
+        }
+
+    def process_option_selection_stream(self, option: dict):
+        """
+        流式处理玩家点击选项。
+        将选项转化为意图格式，然后调用 generate_story_stream。
+        """
+        intent = {
+            "intent": option.get("action_type", "EXPLORE"),
+            "target": None,
+            "details": option.get("text", ""),
+            "raw_input": option.get("text", ""),
+        }
+        yield from self.generate_story_stream(intent)
+
+    def _parse_merged_response(self, raw_text: str) -> tuple:
+        """
+        解析合并格式的响应（THINKING + STORY_TEXT + STATE_JSON + OPTIONS_JSON）。
+
+        Returns:
+            (outline_dict, story_text, options_list)
+            outline_dict 可能为 None（解析失败时）
+        """
+        # ★ 调试日志：记录原始 API 返回内容
+        logger.debug(f"原始 API 返回内容（合并模式）: {raw_text}")
+
+        outline = None
+        story_text = ""
+        options = []
+
+        # 标准化标记格式
+        normalized = _normalize_markers(raw_text)
+
+        # 解析 STORY_TEXT
+        if "---STORY_TEXT---" in normalized:
+            story_start = normalized.index("---STORY_TEXT---") + len("---STORY_TEXT---")
+            # STORY_TEXT 的结尾可能是 STATE_JSON 或 OPTIONS_JSON
+            story_end = len(normalized)
+            if "---STATE_JSON---" in normalized:
+                story_end = normalized.index("---STATE_JSON---")
+            elif "---OPTIONS_JSON---" in normalized:
+                story_end = normalized.index("---OPTIONS_JSON---")
+            story_text = normalized[story_start:story_end].strip()
+
+        # 解析 STATE_JSON
+        if "---STATE_JSON---" in normalized:
+            state_start = normalized.index("---STATE_JSON---") + len("---STATE_JSON---")
+            state_end = len(normalized)
+            if "---OPTIONS_JSON---" in normalized:
+                state_end = normalized.index("---OPTIONS_JSON---")
+            state_part = normalized[state_start:state_end].strip()
+            outline = extract_json_from_text(state_part)
+
+        # 解析 OPTIONS_JSON
+        if "---OPTIONS_JSON---" in normalized:
+            options_start = normalized.index("---OPTIONS_JSON---") + len("---OPTIONS_JSON---")
+            options_part = normalized[options_start:].strip()
+            parsed = extract_json_from_text(options_part)
+            if isinstance(parsed, list):
+                options = parsed
+
+        if not options:
+            options = self._generate_default_options()
+
+        # 确保恰好 3 个选项
+        options = self._ensure_three_options(options)
+
+        if not story_text and outline is None:
+            # 完全解析失败 → 使用暴力提取策略
+            logger.warning("合并格式解析完全失败，使用暴力提取策略")
+            # 先移除 THINKING 区域
+            cleaned = re.sub(r'---THINKING---.*?(?=---[A-Z]|$)', '', raw_text, flags=re.DOTALL | re.IGNORECASE).strip()
+            if not cleaned:
+                cleaned = raw_text
+            story_text, options_fallback = self._brute_force_extract(cleaned)
+            if options_fallback:
+                options = self._ensure_three_options(options_fallback)
+        elif not story_text.strip() and raw_text.strip():
+            # story_text 为空但有原始文本 → 暴力提取
+            logger.warning("story_text 为空，使用暴力提取")
+            cleaned = re.sub(r'---THINKING---.*?(?=---[A-Z]|$)', '', raw_text, flags=re.DOTALL | re.IGNORECASE).strip()
+            if not cleaned:
+                cleaned = raw_text
+            story_text, options_fallback = self._brute_force_extract(cleaned)
+            if options_fallback:
+                options = self._ensure_three_options(options_fallback)
+
+        # 清理 story_text 中可能残留的 JSON 和标记
+        story_text = self._clean_story_text(story_text)
+
+        # 移除常见 AI 前缀
+        story_text = re.sub(r'^(好的[，,]?\s*(这是|以下是|下面是).*?[：:]\s*)', '', story_text, flags=re.MULTILINE)
+
+        # 确保 story_text 不为空
+        if not story_text.strip():
+            story_text = "你环顾四周，思考着接下来该做什么..."
+
+        # 确保选项
+        if not options:
+            options = self._generate_default_options()
+        options = self._ensure_three_options(options)
+
+        return outline, story_text, options

utils.py

@@ -63,8 +63,8 @@ def get_client() -> OpenAI:
 # ============================================================
 # 默认模型配置
 # ============================================================
-# 推荐使用 qwen-plus 平衡速度和效果
-DEFAULT_MODEL: str = "qwen-plus"
+# 使用 qwen-turbo 以获得最快的响应速度
+DEFAULT_MODEL: str = "qwen-turbo"
 
 
 # ============================================================
@@ -132,6 +132,45 @@ def call_qwen(
     )
 
 
+def call_qwen_stream(
+    messages: list[dict[str, str]],
+    model: str = DEFAULT_MODEL,
+    temperature: float = 0.8,
+    max_tokens: int = 2000,
+):
+    """
+    调用 Qwen API 的流式版本，逐块 yield 文本内容。
+
+    使用 stream=True，让用户在 AI 生成过程中就能看到文字逐步出现，
+    大幅改善感知延迟。
+
+    Args:
+        messages: OpenAI 格式的消息列表
+        model: 模型名称
+        temperature: 生成温度
+        max_tokens: 最大生成 token 数
+
+    Yields:
+        每次生成的文本片段（str）
+    """
+    client = get_client()
+    logger.info(f"调用 Qwen 流式 API，模型: {model}")
+    try:
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=True,
+        )
+        for chunk in response:
+            if chunk.choices and chunk.choices[0].delta.content:
+                yield chunk.choices[0].delta.content
+    except Exception as e:
+        logger.error(f"流式 API 调用失败: {e}")
+        raise
+
+
 # ============================================================
 # JSON 安全解析工具
 # ============================================================