Upload 7 files

app.py

@@ -13,62 +13,79 @@ app.py - StoryWeaver Gradio 交互界面
   Gradio UI  ←  状态管理器（校验 + 更新）  ←  叙事引擎（文本 + 选项）
 """
 
-import copy
-import json
-import logging
-from time import perf_counter
-import gradio as gr
-
-from state_manager import GameState
-from nlu_engine import NLUEngine
-from scene_assets import get_scene_image_path
-from story_engine import StoryEngine
-from telemetry import append_turn_log, create_session_metadata
-from utils import logger
-
-APP_UI_CSS = """
-.story-chat {min-height: 500px;}
-.status-panel {
-    font-family: "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
-    font-size: 0.88em;
-    line-height: 1.6;
-}
-.option-btn {min-height: 50px !important;}
-.scene-sidebar {gap: 14px;}
-.scene-card {
-    border: 1px solid rgba(161, 125, 83, 0.14) !important;
-    border-radius: 18px !important;
-    background:
-        linear-gradient(180deg, rgba(255, 249, 241, 0.98) 0%,
-        rgba(246, 238, 226, 0.96) 100%) !important;
-    box-shadow: 0 14px 28px rgba(110, 81, 49, 0.08) !important;
-}
-.scene-image {
-    min-height: 280px;
-    padding: 14px !important;
-}
-.scene-image > div,
-.scene-image img,
-.scene-image button,
-.scene-image [class*="image"],
-.scene-image [class*="wrap"],
-.scene-image [class*="frame"],
-.scene-image [class*="preview"] {
-    border: none !important;
-    box-shadow: none !important;
-    background: transparent !important;
-}
-.scene-image img {
-    width: 100%;
-    height: 100%;
-    object-fit: contain !important;
-    border-radius: 14px;
-    padding: 8px;
-    background:
-        radial-gradient(circle at top, rgba(255, 255, 255, 0.95) 0%,
-        rgba(247, 239, 227, 0.92) 100%) !important;
-}
-"""
+import copy
+import html
+import json
+import logging
+from time import perf_counter
+import gradio as gr
+
+from state_manager import GameState
+from nlu_engine import NLUEngine
+from scene_assets import get_scene_image_path
+from story_engine import StoryEngine
+from telemetry import append_turn_log, create_session_metadata
+from utils import logger
+
+APP_UI_CSS = """
+.story-chat {min-height: 500px;}
+.status-panel {
+    font-family: "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    font-size: 0.9em;
+    line-height: 1.5;
+    background: transparent !important;
+    border: none !important;
+    border-radius: 0 !important;
+    padding: 10px 12px !important;
+    box-shadow: none !important;
+    overflow: visible !important;
+}
+.status-panel > div,
+.status-panel [class*="prose"],
+.status-panel .markdown-body,
+.status-panel [class*="wrap"] {
+    background: transparent !important;
+    border: none !important;
+    box-shadow: none !important;
+    padding: 0 !important;
+    overflow: visible !important;
+}
+.status-panel * {
+    word-break: break-word;
+    overflow-wrap: anywhere;
+}
+.option-btn {min-height: 50px !important;}
+.scene-sidebar {gap: 12px;}
+.scene-card {
+    border: 1px solid #e5e7eb !important;
+    border-radius: 12px !important;
+    background: #fcfcfd !important;
+    box-shadow: 0 4px 14px rgba(15, 23, 42, 0.04) !important;
+}
+.scene-image {
+    min-height: 260px;
+    padding: 10px !important;
+}
+.scene-image > div,
+.scene-image img,
+.scene-image button,
+.scene-image [class*="image"],
+.scene-image [class*="wrap"],
+.scene-image [class*="frame"],
+.scene-image [class*="preview"] {
+    border: none !important;
+    box-shadow: none !important;
+    background: transparent !important;
+}
+.scene-image img {
+    width: 100%;
+    height: 100%;
+    object-fit: contain !important;
+    border-radius: 10px;
+    padding: 4px;
+    background: #ffffff !important;
+}
+"""
 
 # ============================================================
 # 全局游戏实例（每个会话独立）
@@ -78,158 +95,458 @@ APP_UI_CSS = """
 # 这里先定义工厂函数
 
 
-def create_new_game(player_name: str = "旅人") -> dict:
-    """创建新游戏实例，返回包含所有引擎的字典"""
-    game_state = GameState(player_name=player_name)
-    nlu = NLUEngine(game_state)
-    story = StoryEngine(game_state, enable_rule_text_polish=True)
-    return {
-        "game_state": game_state,
-        "nlu": nlu,
-        "story": story,
-        "current_options": [],
-        "started": False,
-        **create_session_metadata(),
-    }
-
-
-def _json_safe(value):
-    """Convert nested values into JSON-serializable data for logs."""
-    if value is None or isinstance(value, (str, int, float, bool)):
-        return value
-    if isinstance(value, dict):
-        return {str(key): _json_safe(val) for key, val in value.items()}
-    if isinstance(value, (list, tuple, set)):
-        return [_json_safe(item) for item in value]
-    if hasattr(value, "model_dump"):
-        return _json_safe(value.model_dump())
-    return str(value)
-
-
-def _build_state_snapshot(gs: GameState) -> dict:
-    """Build a compact state snapshot for reproducible evaluation logs."""
-    active_quests = []
-    effective_stats = gs.get_effective_player_stats()
-    equipment_bonuses = gs.get_equipment_stat_bonuses()
-    environment_snapshot = gs.get_environment_snapshot(limit=3)
-    for quest in gs.world.quests.values():
-        if quest.status == "active":
-            active_quests.append(
-                {
-                    "quest_id": quest.quest_id,
-                    "title": quest.title,
-                    "status": quest.status,
-                    "objectives": _json_safe(quest.objectives),
-                }
-            )
-
-    return {
-        "turn": gs.turn,
-        "game_mode": gs.game_mode,
-        "location": gs.player.location,
-        "scene": gs.world.current_scene,
-        "day": gs.world.day_count,
-        "time_of_day": gs.world.time_of_day,
-        "weather": gs.world.weather,
-        "light_level": gs.world.light_level,
-        "environment": _json_safe(environment_snapshot),
-        "player": {
-            "name": gs.player.name,
-            "level": gs.player.level,
-            "hp": gs.player.hp,
-            "max_hp": gs.player.max_hp,
-            "mp": gs.player.mp,
-            "max_mp": gs.player.max_mp,
-            "attack": gs.player.attack,
-            "defense": gs.player.defense,
-            "speed": gs.player.speed,
-            "luck": gs.player.luck,
-            "perception": gs.player.perception,
-            "gold": gs.player.gold,
-            "morale": gs.player.morale,
-            "sanity": gs.player.sanity,
-            "hunger": gs.player.hunger,
-            "karma": gs.player.karma,
-            "effective_stats": _json_safe(effective_stats),
-            "equipment_bonuses": _json_safe(equipment_bonuses),
-            "inventory": list(gs.player.inventory),
-            "equipment": copy.deepcopy(gs.player.equipment),
-            "skills": list(gs.player.skills),
-            "status_effects": [effect.name for effect in gs.player.status_effects],
-        },
-        "active_quests": active_quests,
-        "event_log_size": len(gs.event_log),
-    }
-
-
-def _record_interaction_log(
-    game_session: dict,
-    *,
-    input_source: str,
-    user_input: str,
-    intent_result: dict | None,
-    output_text: str,
-    latency_ms: float,
-    nlu_latency_ms: float | None = None,
-    generation_latency_ms: float | None = None,
-    final_result: dict | None = None,
-    selected_option: dict | None = None,
-):
-    """Append a structured interaction log without affecting gameplay."""
-    if not game_session or "game_state" not in game_session:
-        return
-
-    final_result = final_result or {}
-    telemetry = _json_safe(final_result.get("telemetry", {})) or {}
-    record = {
-        "input_source": input_source,
-        "user_input": user_input,
-        "selected_option": _json_safe(selected_option),
-        "nlu_result": _json_safe(intent_result),
-        "latency_ms": round(latency_ms, 2),
-        "nlu_latency_ms": None if nlu_latency_ms is None else round(nlu_latency_ms, 2),
-        "generation_latency_ms": None if generation_latency_ms is None else round(generation_latency_ms, 2),
-        "used_fallback": bool(telemetry.get("used_fallback", False)),
-        "fallback_reason": telemetry.get("fallback_reason"),
-        "engine_mode": telemetry.get("engine_mode"),
-        "state_changes": _json_safe(final_result.get("state_changes", {})),
-        "change_log": _json_safe(final_result.get("change_log", [])),
-        "consistency_issues": _json_safe(final_result.get("consistency_issues", [])),
-        "output_text": output_text,
-        "story_text": final_result.get("story_text"),
-        "options": _json_safe(final_result.get("options", game_session.get("current_options", []))),
-        "post_turn_snapshot": _build_state_snapshot(game_session["game_state"]),
-    }
-
-    try:
-        append_turn_log(game_session, record)
-    except Exception as exc:
-        logger.warning(f"Failed to append interaction log: {exc}")
-
-
-def _build_option_intent(selected_option: dict) -> dict:
-    """Represent button clicks in the same schema as free-text NLU output."""
-    option_text = selected_option.get("text", "")
-    return {
-        "intent": selected_option.get("action_type", "EXPLORE"),
-        "target": selected_option.get("target"),
-        "details": option_text,
-        "raw_input": option_text,
-        "parser_source": "option_click",
-    }
-
-
-def _get_scene_image_value(gs: GameState) -> str | None:
-    focus_npc = getattr(gs, "last_interacted_npc", None)
-    return get_scene_image_path(gs, focus_npc=focus_npc)
-
-
-def _get_scene_image_update(gs: GameState):
-    image_value = _get_scene_image_value(gs)
-    return gr.update(value=image_value, visible=bool(image_value))
-
-
-def restart_game() -> tuple:
+def create_new_game(player_name: str = "旅人") -> dict:
+    """创建新游戏实例，返回包含所有引擎的字典"""
+    game_state = GameState(player_name=player_name)
+    nlu = NLUEngine(game_state)
+    story = StoryEngine(game_state, enable_rule_text_polish=True)
+    return {
+        "game_state": game_state,
+        "nlu": nlu,
+        "story": story,
+        "current_options": [],
+        "started": False,
+        **create_session_metadata(),
+    }
+
+
+def _json_safe(value):
+    """Convert nested values into JSON-serializable data for logs."""
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, dict):
+        return {str(key): _json_safe(val) for key, val in value.items()}
+    if isinstance(value, (list, tuple, set)):
+        return [_json_safe(item) for item in value]
+    if hasattr(value, "model_dump"):
+        return _json_safe(value.model_dump())
+    return str(value)
+
+
+def _build_state_snapshot(gs: GameState) -> dict:
+    """Build a compact state snapshot for reproducible evaluation logs."""
+    active_quests = []
+    effective_stats = gs.get_effective_player_stats()
+    equipment_bonuses = gs.get_equipment_stat_bonuses()
+    environment_snapshot = gs.get_environment_snapshot(limit=3)
+    for quest in gs.world.quests.values():
+        if quest.status == "active":
+            active_quests.append(
+                {
+                    "quest_id": quest.quest_id,
+                    "title": quest.title,
+                    "status": quest.status,
+                    "objectives": _json_safe(quest.objectives),
+                }
+            )
+
+    return {
+        "turn": gs.turn,
+        "game_mode": gs.game_mode,
+        "location": gs.player.location,
+        "scene": gs.world.current_scene,
+        "day": gs.world.day_count,
+        "time_of_day": gs.world.time_of_day,
+        "weather": gs.world.weather,
+        "light_level": gs.world.light_level,
+        "environment": _json_safe(environment_snapshot),
+        "player": {
+            "name": gs.player.name,
+            "level": gs.player.level,
+            "hp": gs.player.hp,
+            "max_hp": gs.player.max_hp,
+            "mp": gs.player.mp,
+            "max_mp": gs.player.max_mp,
+            "attack": gs.player.attack,
+            "defense": gs.player.defense,
+            "speed": gs.player.speed,
+            "luck": gs.player.luck,
+            "perception": gs.player.perception,
+            "gold": gs.player.gold,
+            "morale": gs.player.morale,
+            "sanity": gs.player.sanity,
+            "hunger": gs.player.hunger,
+            "karma": gs.player.karma,
+            "effective_stats": _json_safe(effective_stats),
+            "equipment_bonuses": _json_safe(equipment_bonuses),
+            "inventory": list(gs.player.inventory),
+            "equipment": copy.deepcopy(gs.player.equipment),
+            "skills": list(gs.player.skills),
+            "status_effects": [effect.name for effect in gs.player.status_effects],
+        },
+        "active_quests": active_quests,
+        "event_log_size": len(gs.event_log),
+    }
+
+
+def _record_interaction_log(
+    game_session: dict,
+    *,
+    input_source: str,
+    user_input: str,
+    intent_result: dict | None,
+    output_text: str,
+    latency_ms: float,
+    nlu_latency_ms: float | None = None,
+    generation_latency_ms: float | None = None,
+    final_result: dict | None = None,
+    selected_option: dict | None = None,
+):
+    """Append a structured interaction log without affecting gameplay."""
+    if not game_session or "game_state" not in game_session:
+        return
+
+    final_result = final_result or {}
+    telemetry = _json_safe(final_result.get("telemetry", {})) or {}
+    record = {
+        "input_source": input_source,
+        "user_input": user_input,
+        "selected_option": _json_safe(selected_option),
+        "nlu_result": _json_safe(intent_result),
+        "latency_ms": round(latency_ms, 2),
+        "nlu_latency_ms": None if nlu_latency_ms is None else round(nlu_latency_ms, 2),
+        "generation_latency_ms": None if generation_latency_ms is None else round(generation_latency_ms, 2),
+        "used_fallback": bool(telemetry.get("used_fallback", False)),
+        "fallback_reason": telemetry.get("fallback_reason"),
+        "engine_mode": telemetry.get("engine_mode"),
+        "state_changes": _json_safe(final_result.get("state_changes", {})),
+        "change_log": _json_safe(final_result.get("change_log", [])),
+        "consistency_issues": _json_safe(final_result.get("consistency_issues", [])),
+        "output_text": output_text,
+        "story_text": final_result.get("story_text"),
+        "options": _json_safe(final_result.get("options", game_session.get("current_options", []))),
+        "post_turn_snapshot": _build_state_snapshot(game_session["game_state"]),
+    }
+
+    try:
+        append_turn_log(game_session, record)
+    except Exception as exc:
+        logger.warning(f"Failed to append interaction log: {exc}")
+
+
+def _build_option_intent(selected_option: dict) -> dict:
+    """Represent button clicks in the same schema as free-text NLU output."""
+    option_text = selected_option.get("text", "")
+    return {
+        "intent": selected_option.get("action_type", "EXPLORE"),
+        "target": selected_option.get("target"),
+        "details": option_text,
+        "raw_input": option_text,
+        "parser_source": "option_click",
+    }
+
+
+def _get_scene_image_value(gs: GameState) -> str | None:
+    focus_npc = getattr(gs, "last_interacted_npc", None)
+    return get_scene_image_path(gs, focus_npc=focus_npc)
+
+
+def _get_scene_image_update(gs: GameState):
+    image_value = _get_scene_image_value(gs)
+    return gr.update(value=image_value, visible=bool(image_value))
+
+
+def _build_map_graph_data(gs: GameState) -> dict:
+    """基于已发现地点与连接关系构建地图拓扑数据。"""
+    world_locations = getattr(getattr(gs, "world", None), "locations", {}) or {}
+    discovered = list(getattr(getattr(gs, "world", None), "discovered_locations", []) or [])
+    history = list(getattr(gs, "location_history", []) or [])
+
+    current_location = str(getattr(gs, "current_location", None) or "").strip()
+    if not current_location:
+        current_location = str(getattr(getattr(gs, "player", None), "location", None) or "未知之地")
+
+    visible_set: set[str] = set(discovered) | set(history)
+    if current_location:
+        visible_set.add(current_location)
+
+    # 使用世界注册顺序保证地图输出稳定，便于玩家快速扫描。
+    ordered_nodes: list[str] = [name for name in world_locations.keys() if name in visible_set]
+    for name in discovered + history + [current_location]:
+        if name and name in visible_set and name not in ordered_nodes:
+            ordered_nodes.append(name)
+
+    visited_set = set(history)
+    if current_location:
+        visited_set.add(current_location)
+
+    adjacency: dict[str, list[str]] = {}
+    for node in ordered_nodes:
+        loc_info = world_locations.get(node)
+        if not loc_info:
+            adjacency[node] = []
+            continue
+        neighbors = []
+        for neighbor in list(getattr(loc_info, "connected_to", []) or []):
+            if neighbor in visible_set and neighbor != node:
+                neighbors.append(neighbor)
+        adjacency[node] = neighbors
+
+    node_state: dict[str, str] = {}
+    for node in ordered_nodes:
+        if node == current_location:
+            node_state[node] = "current"
+        elif node in visited_set:
+            node_state[node] = "visited"
+        else:
+            node_state[node] = "known"
+
+    return {
+        "current_location": current_location,
+        "nodes": ordered_nodes,
+        "adjacency": adjacency,
+        "node_state": node_state,
+    }
+
+
+def _build_location_hover_text(gs: GameState, location_name: str) -> str:
+    """构造地点 hover 提示：展示 NPC 与怪物。"""
+    world = getattr(gs, "world", None)
+    locations = getattr(world, "locations", {}) or {}
+    npcs = getattr(world, "npcs", {}) or {}
+    loc = locations.get(location_name)
+    if not loc:
+        return f"{location_name}\nNPC: 无\n怪物: 无"
+
+    npc_names: set[str] = set(getattr(loc, "npcs_present", []) or [])
+    for npc in npcs.values():
+        if getattr(npc, "location", None) == location_name and getattr(npc, "is_alive", True):
+            npc_names.add(getattr(npc, "name", ""))
+    npc_names = {name for name in npc_names if name}
+
+    enemy_names = [str(name) for name in list(getattr(loc, "enemies", []) or []) if str(name)]
+    npc_text = "、".join(sorted(npc_names)) if npc_names else "无"
+    enemy_text = "、".join(enemy_names) if enemy_names else "无"
+    return f"{location_name}\nNPC: {npc_text}\n怪物: {enemy_text}"
+
+
+def _truncate_map_label(name: str, max_len: int = 8) -> str:
+    text = str(name or "")
+    return text if len(text) <= max_len else f"{text[:max_len]}..."
+
+
+def _build_fixed_branch_layout(nodes: list[str], adjacency: dict[str, list[str]]) -> dict[str, tuple[int, int]]:
+    """固定起点的分层布局：保持总体顺序稳定，同时展示分支。"""
+    if not nodes:
+        return {}
+
+    node_set = set(nodes)
+    layers: dict[str, int] = {}
+
+    def _bfs(seed: str, base_layer: int) -> None:
+        if seed not in node_set or seed in layers:
+            return
+        queue: list[str] = [seed]
+        layers[seed] = base_layer
+        cursor = 0
+        while cursor < len(queue):
+            node = queue[cursor]
+            cursor += 1
+            next_layer = layers[node] + 1
+            for nxt in adjacency.get(node, []):
+                if nxt in node_set and nxt not in layers:
+                    layers[nxt] = next_layer
+                    queue.append(nxt)
+
+    # 第一出现地点作为固定起点，避免因当前位置变化而重排。
+    _bfs(nodes[0], 0)
+    for name in nodes:
+        if name not in layers:
+            base = (max(layers.values()) + 1) if layers else 0
+            _bfs(name, base)
+
+    level_nodes: dict[int, list[str]] = {}
+    for name in nodes:
+        level = layers.get(name, 0)
+        level_nodes.setdefault(level, []).append(name)
+
+    positions: dict[str, tuple[int, int]] = {}
+    for col_idx, level in enumerate(sorted(level_nodes.keys())):
+        for row_idx, name in enumerate(level_nodes[level]):
+            positions[name] = (col_idx, row_idx)
+    return positions
+
+
+def _render_text_map(gs: GameState | None) -> str:
+    """拓扑地图：从左到右显示地点关系图。"""
+    if gs is None:
+        return "地图关系图\n（未开始）"
+
+    graph = _build_map_graph_data(gs)
+    nodes = graph["nodes"]
+    adjacency = graph["adjacency"]
+    node_state = graph["node_state"]
+    current_location = graph["current_location"]
+
+    if not nodes:
+        current = current_location or "未知之地"
+        return f"地图关系图\n当前位置：{current}"
+
+    positions = _build_fixed_branch_layout(nodes, adjacency)
+    if not positions:
+        return "地图关系图\n（暂无可显示节点）"
+
+    node_width = 110
+    node_height = 34
+    col_gap = 140
+    row_gap = 50
+    x_margin = 16
+    y_margin = 16
+
+    max_col = max(col for col, _ in positions.values())
+    max_row = max(row for _, row in positions.values())
+    canvas_width = x_margin * 2 + max_col * col_gap + node_width
+    canvas_height = y_margin * 2 + max_row * row_gap + node_height
+    canvas_height = max(canvas_height, 74)
+
+    node_boxes: dict[str, tuple[int, int, int, int]] = {}
+    centers: dict[str, tuple[int, int]] = {}
+    for name, (col, row) in positions.items():
+        x = x_margin + col * col_gap
+        y = y_margin + row * row_gap
+        node_boxes[name] = (x, y, node_width, node_height)
+        centers[name] = (x + node_width // 2, y + node_height // 2)
+
+    edge_pairs: set[tuple[str, str]] = set()
+    for source, neighbors in adjacency.items():
+        for target in neighbors:
+            if source in positions and target in positions and source != target:
+                edge_pairs.add(tuple(sorted((source, target))))
+
+    edge_svg: list[str] = []
+
+    def _segment_hits_box_horizontal(y: float, x_start: float, x_end: float, box: tuple[int, int, int, int]) -> bool:
+        bx, by, bw, bh = box
+        left = min(x_start, x_end)
+        right = max(x_start, x_end)
+        return (by + 1) <= y <= (by + bh - 1) and not (right <= bx + 1 or left >= bx + bw - 1)
+
+    def _segment_hits_box_vertical(x: float, y_start: float, y_end: float, box: tuple[int, int, int, int]) -> bool:
+        bx, by, bw, bh = box
+        top = min(y_start, y_end)
+        bottom = max(y_start, y_end)
+        return (bx + 1) <= x <= (bx + bw - 1) and not (bottom <= by + 1 or top >= by + bh - 1)
+
+    for source, target in sorted(edge_pairs):
+        sx, sy, sw, sh = node_boxes[source]
+        tx, ty, tw, th = node_boxes[target]
+        source_exit_x = sx + sw
+        source_exit_y = sy + sh / 2
+        target_entry_x = tx
+        target_entry_y = ty + th / 2
+
+        mid_x = (source_exit_x + target_entry_x) / 2
+        needs_detour = False
+        for name, box in node_boxes.items():
+            if name in {source, target}:
+                continue
+            if (
+                _segment_hits_box_horizontal(source_exit_y, source_exit_x, mid_x, box)
+                or _segment_hits_box_vertical(mid_x, source_exit_y, target_entry_y, box)
+                or _segment_hits_box_horizontal(target_entry_y, mid_x, target_entry_x, box)
+            ):
+                needs_detour = True
+                break
+
+        if not needs_detour:
+            points = (
+                f"{source_exit_x},{source_exit_y} "
+                f"{mid_x},{source_exit_y} "
+                f"{mid_x},{target_entry_y} "
+                f"{target_entry_x},{target_entry_y}"
+            )
+        else:
+            # 局部上绕：仅在必要时走上方，减少杂乱感同时避免压到节点。
+            route_y = max(4, min(source_exit_y, target_entry_y) - node_height / 2 - 10)
+            route_left_x = source_exit_x + 6
+            route_right_x = target_entry_x - 6
+            points = (
+                f"{source_exit_x},{source_exit_y} "
+                f"{route_left_x},{source_exit_y} "
+                f"{route_left_x},{route_y} "
+                f"{route_right_x},{route_y} "
+                f"{route_right_x},{target_entry_y} "
+                f"{target_entry_x},{target_entry_y}"
+            )
+
+        edge_svg.append(
+            f"<polyline points='{points}' "
+            "fill='none' stroke='#94a3b8' stroke-width='1.7' "
+            "stroke-linecap='round' stroke-linejoin='round' />"
+        )
+
+    node_svg: list[str] = []
+    for name in nodes:
+        col, row = positions[name]
+        x = x_margin + col * col_gap
+        y = y_margin + row * row_gap
+        state = node_state.get(name, "known")
+        escaped_name = html.escape(_truncate_map_label(name))
+        hover_text = html.escape(_build_location_hover_text(gs, name))
+
+        if state == "current":
+            fill = "#fff7ed"
+            stroke = "#f97316"
+            text_color = "#9a3412"
+            stroke_width = 1.8
+            display_name = escaped_name
+        elif state == "visited":
+            fill = "#f1f5f9"
+            stroke = "#64748b"
+            text_color = "#334155"
+            stroke_width = 1.4
+            display_name = escaped_name
+        else:
+            fill = "#ffffff"
+            stroke = "#cbd5e1"
+            text_color = "#334155"
+            stroke_width = 1.2
+            display_name = escaped_name
+
+        rect_class_attr = " class='map-current-node'" if state == "current" else ""
+        node_svg.append(
+            "<g cursor='help'>"
+            f"<title>{hover_text}</title>"
+            f"<rect x='{x}' y='{y}' width='{node_width}' height='{node_height}' "
+            f"rx='8' ry='8' fill='{fill}' stroke='{stroke}' stroke-width='{stroke_width}'{rect_class_attr} />"
+            f"<text x='{x + node_width / 2}' y='{y + node_height / 2 + 5}' "
+            "text-anchor='middle' font-size='11.5' font-family='Microsoft YaHei UI, Noto Sans SC, sans-serif' "
+            f"fill='{text_color}'>{display_name}</text>"
+            "</g>"
+        )
+
+    svg = (
+        f"<svg width='{canvas_width}' height='{canvas_height}' viewBox='0 0 {canvas_width} {canvas_height}' "
+        "xmlns='http://www.w3.org/2000/svg'>"
+        "<style>"
+        "@keyframes mapNodePulse{"
+        "0%{fill:#fff7ed;stroke:#f97316;stroke-width:1.8;opacity:0.9;}"
+        "50%{fill:#fdba74;stroke:#c2410c;stroke-width:1.8;opacity:1;}"
+        "100%{fill:#fff7ed;stroke:#f97316;stroke-width:1.8;opacity:0.9;}"
+        "}"
+        ".map-current-node{animation:mapNodePulse 1.2s ease-in-out infinite;}"
+        "</style>"
+        + "".join(edge_svg)
+        + "".join(node_svg)
+        + "</svg>"
+    )
+
+    return (
+        "<div style='font-size:0.9em;'>"
+        "<details>"
+        "<summary style='cursor:pointer;font-weight:700;'>展开地图关系图</summary>"
+        "<div style='font-size:0.8em;color:#475569;margin:8px 0 6px 0;'>"
+        "鼠标悬停于地点格可查看NPC与怪物。"
+        "</div>"
+        "<div style='overflow-x:auto;padding-bottom:2px;'>"
+        + svg
+        + "</div>"
+        "</details>"
+        "</div>"
+    )
+
+
+def restart_game() -> tuple:
     """
     重启冒险：清空所有数据，回到初始输入名称阶段。
 
@@ -238,15 +555,17 @@ def restart_game() -> tuple:
          禁用文本输入框, 重置角色名称)
     """
     loading = _get_loading_button_updates()
-    return (
-        [],                                                          # 清空聊天历史
-        "## 等待开始...\n\n请输入角色名称并点击「开始冒险」",         # 重置状态面板
-        gr.update(value=None, visible=False),                        # 清空场景图片
-        *loading,                                                    # 占位选项按钮
-        {},                                                          # 清空游戏会话
-        gr.update(value="", interactive=False),                       # 禁用并清空文本输入
-        gr.update(value="旅人"),                                      # 重置角色名称
-    )
+    return (
+        [],                                                          # 清空聊天历史
+        _format_world_info_panel(None),                              # 重置世界信息
+        "## 等待开始...\n\n请输入角色名称并点击「开始冒险」",         # 重置状态面板
+        "地图关系图\n（未开始）",                                      # 清空地图
+        gr.update(value=None, visible=False),                        # 清空场景图片
+        *loading,                                                    # 占位选项按钮
+        {},                                                          # 清空游戏会话
+        gr.update(value="", interactive=False),                       # 禁用并清空文本输入
+        gr.update(value="旅人"),                                      # 重置角色名称
+    )
 
 
 # ============================================================
@@ -269,35 +588,44 @@ def start_game(player_name: str, game_session: dict):
 
     # 初始 yield：显示加载状态，按钮保持可见但禁用
     chat_history = [{"role": "assistant", "content": "⏳ 正在生成开场..."}]
+    world_info_text = _format_world_info_panel(game_session["game_state"])
     status_text = _format_status_panel(game_session["game_state"])
     loading = _get_loading_button_updates()
 
-    yield (
-        chat_history, status_text, _get_scene_image_update(game_session["game_state"]),
-        *loading,
-        game_session,
-        gr.update(interactive=False),
-    )
+    yield (
+        chat_history,
+        world_info_text,
+        status_text,
+        _render_text_map(game_session["game_state"]),
+        _get_scene_image_update(game_session["game_state"]),
+        *loading,
+        game_session,
+        gr.update(interactive=False),
+    )
 
     # 流式生成开场（选项仅在流结束后从 final 事件中提取，流式期间不解析选项）
-    turn_started = perf_counter()
-    story_text = ""
+    turn_started = perf_counter()
+    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, _get_scene_image_update(game_session["game_state"]),
-                *loading,
-                game_session,
-                gr.update(interactive=False),
-            )
+            yield (
+                chat_history,
+                world_info_text,
+                status_text,
+                _render_text_map(game_session["game_state"]),
+                _get_scene_image_update(game_session["game_state"]),
+                *loading,
+                game_session,
+                gr.update(interactive=False),
+            )
         elif update["type"] == "final":
-            final_result = update
-
-    generation_latency_ms = (perf_counter() - turn_started) * 1000
+            final_result = update
+
+    generation_latency_ms = (perf_counter() - turn_started) * 1000
 
     # ★ 只在数据流完全结束后，从 final_result 中提取选项
     if final_result:
@@ -307,46 +635,50 @@ def start_game(player_name: str, game_session: dict):
         options = []
 
     # ★ 安全兜底：强制确保恰好 3 个选项
-    options = _finalize_session_options(options)
+    options = _finalize_session_options(options)
 
     # 最终 yield：显示完整文本 + 选项 + 启用按钮
-    game_session["current_options"] = options
-    options_text = _format_options(options)
-    full_message = f"{story_text}\n\n{options_text}"
-    if not final_result:
-        final_result = {
-            "story_text": story_text,
-            "options": options,
-            "state_changes": {},
-            "change_log": [],
-            "consistency_issues": [],
-            "telemetry": {
-                "engine_mode": "opening_app",
-                "used_fallback": True,
-                "fallback_reason": "missing_final_event",
-            },
-        }
-
-    chat_history[-1]["content"] = full_message
-    status_text = _format_status_panel(game_session["game_state"])
-    btn_updates = _get_button_updates(options)
-    _record_interaction_log(
-        game_session,
-        input_source="system_opening",
-        user_input="",
-        intent_result=None,
-        output_text=full_message,
-        latency_ms=generation_latency_ms,
-        generation_latency_ms=generation_latency_ms,
-        final_result=final_result,
-    )
-
-    yield (
-        chat_history, status_text, _get_scene_image_update(game_session["game_state"]),
-        *btn_updates,
-        game_session,
-        gr.update(interactive=True),
-    )
+    game_session["current_options"] = options
+    full_message = story_text
+    if not final_result:
+        final_result = {
+            "story_text": story_text,
+            "options": options,
+            "state_changes": {},
+            "change_log": [],
+            "consistency_issues": [],
+            "telemetry": {
+                "engine_mode": "opening_app",
+                "used_fallback": True,
+                "fallback_reason": "missing_final_event",
+            },
+        }
+
+    chat_history[-1]["content"] = full_message
+    world_info_text = _format_world_info_panel(game_session["game_state"])
+    status_text = _format_status_panel(game_session["game_state"])
+    btn_updates = _get_button_updates(options)
+    _record_interaction_log(
+        game_session,
+        input_source="system_opening",
+        user_input="",
+        intent_result=None,
+        output_text=full_message,
+        latency_ms=generation_latency_ms,
+        generation_latency_ms=generation_latency_ms,
+        final_result=final_result,
+    )
+
+    yield (
+        chat_history,
+        world_info_text,
+        status_text,
+        _render_text_map(game_session["game_state"]),
+        _get_scene_image_update(game_session["game_state"]),
+        *btn_updates,
+        game_session,
+        gr.update(interactive=True),
+    )
 
 
 def process_user_input(user_input: str, chat_history: list, game_session: dict):
@@ -358,138 +690,153 @@ def process_user_input(user_input: str, chat_history: list, game_session: dict):
     2. 叙事引擎流式生成故事
     3. 逐步更新 UI
     """
-    if not game_session or not game_session.get("started"):
-        chat_history = chat_history or []
-        chat_history.append({"role": "assistant", "content": "请先点击「开始冒险」按钮！"})
-        loading = _get_loading_button_updates()
-        yield (
-            chat_history, "", gr.update(value=None, visible=False),
-            *loading,
-            game_session,
-        )
-        return
-
-    if not user_input.strip():
-        btn_updates = _get_button_updates(game_session.get("current_options", []))
-        yield (
-            chat_history, _format_status_panel(game_session["game_state"]), _get_scene_image_update(game_session["game_state"]),
-            *btn_updates,
-            game_session,
-        )
-        return
-
-    gs: GameState = game_session["game_state"]
-    nlu: NLUEngine = game_session["nlu"]
-    story: StoryEngine = game_session["story"]
-    turn_started = perf_counter()
+    if not game_session or not game_session.get("started"):
+        chat_history = chat_history or []
+        chat_history.append({"role": "assistant", "content": "请先点击「开始冒险」按钮！"})
+        loading = _get_loading_button_updates()
+        yield (
+            chat_history,
+            _format_world_info_panel(None),
+            "",
+            "",
+            gr.update(value=None, visible=False),
+            *loading,
+            game_session,
+        )
+        return
+
+    if not user_input.strip():
+        btn_updates = _get_button_updates(game_session.get("current_options", []))
+        yield (
+            chat_history,
+            _format_world_info_panel(game_session["game_state"]),
+            _format_status_panel(game_session["game_state"]),
+            _render_text_map(game_session["game_state"]),
+            _get_scene_image_update(game_session["game_state"]),
+            *btn_updates,
+            game_session,
+        )
+        return
+
+    gs: GameState = game_session["game_state"]
+    nlu: NLUEngine = game_session["nlu"]
+    story: StoryEngine = game_session["story"]
+    turn_started = perf_counter()
 
     # 检查游戏是否已结束
-    if gs.is_game_over():
-        chat_history.append({"role": "user", "content": user_input})
-        chat_history.append({"role": "assistant", "content": "游戏已结束。请点击「重新开始」按钮开始新的冒险。"})
-        restart_buttons = _get_button_updates(
-            [
-                {"id": 1, "text": "重新开始", "action_type": "RESTART"},
-            ]
-        )
-        yield (
-            chat_history,
-            _format_status_panel(gs),
-            _get_scene_image_update(gs),
-            *restart_buttons,
-            game_session,
-        )
-        return
-
-    # 1. NLU 解析
-    nlu_started = perf_counter()
-    intent = nlu.parse_intent(user_input)
-    nlu_latency_ms = (perf_counter() - nlu_started) * 1000
+    if gs.is_game_over():
+        chat_history.append({"role": "user", "content": user_input})
+        chat_history.append({"role": "assistant", "content": "游戏已结束。请点击「重新开始」按钮开始新的冒险。"})
+        restart_buttons = _get_button_updates(
+            [
+                {"id": 1, "text": "重新开始", "action_type": "RESTART"},
+            ]
+        )
+        yield (
+            chat_history,
+            _format_world_info_panel(gs),
+            _format_status_panel(gs),
+            _render_text_map(gs),
+            _get_scene_image_update(gs),
+            *restart_buttons,
+            game_session,
+        )
+        return
+
+    # 1. NLU 解析
+    nlu_started = perf_counter()
+    intent = nlu.parse_intent(user_input)
+    nlu_latency_ms = (perf_counter() - nlu_started) * 1000
 
     # 1.5 预校验：立即驳回违反一致性的操作（不调用 LLM，不消耗回合）
     is_valid, rejection_msg = gs.pre_validate_action(intent)
     if not is_valid:
-        chat_history.append({"role": "user", "content": user_input})
-        options = game_session.get("current_options", [])
-        options = _finalize_session_options(options)
-        options_text = _format_options(options)
+        chat_history.append({"role": "user", "content": user_input})
+        options = game_session.get("current_options", [])
+        options = _finalize_session_options(options)
         rejection_content = (
             f"⚠️ **行动被驳回**：{rejection_msg}\n\n"
-            f"请重新选择行动，或输入其他指令。\n\n{options_text}"
+            f"请重新选择行动，或输入其他指令。"
+        )
+        chat_history.append({"role": "assistant", "content": rejection_content})
+        rejection_result = {
+            "story_text": rejection_content,
+            "options": options,
+            "state_changes": {},
+            "change_log": [],
+            "consistency_issues": [],
+            "telemetry": {
+                "engine_mode": "pre_validation",
+                "used_fallback": False,
+                "fallback_reason": None,
+            },
+        }
+        _record_interaction_log(
+            game_session,
+            input_source="text_input",
+            user_input=user_input,
+            intent_result=intent,
+            output_text=rejection_content,
+            latency_ms=(perf_counter() - turn_started) * 1000,
+            nlu_latency_ms=nlu_latency_ms,
+            generation_latency_ms=0.0,
+            final_result=rejection_result,
         )
-        chat_history.append({"role": "assistant", "content": rejection_content})
-        rejection_result = {
-            "story_text": rejection_content,
-            "options": options,
-            "state_changes": {},
-            "change_log": [],
-            "consistency_issues": [],
-            "telemetry": {
-                "engine_mode": "pre_validation",
-                "used_fallback": False,
-                "fallback_reason": None,
-            },
-        }
-        _record_interaction_log(
-            game_session,
-            input_source="text_input",
-            user_input=user_input,
-            intent_result=intent,
-            output_text=rejection_content,
-            latency_ms=(perf_counter() - turn_started) * 1000,
-            nlu_latency_ms=nlu_latency_ms,
-            generation_latency_ms=0.0,
-            final_result=rejection_result,
-        )
-        btn_updates = _get_button_updates(options)
-        yield (
-            chat_history,
-            _format_status_panel(gs),
-            _get_scene_image_update(gs),
-            *btn_updates,
-            game_session,
-        )
-        return
+        btn_updates = _get_button_updates(options)
+        yield (
+            chat_history,
+            _format_world_info_panel(gs),
+            _format_status_panel(gs),
+            _render_text_map(gs),
+            _get_scene_image_update(gs),
+            *btn_updates,
+            game_session,
+        )
+        return
 
     # 2. 添加用户消息 + 空的 assistant 消息（用于流式填充）
     chat_history.append({"role": "user", "content": user_input})
     chat_history.append({"role": "assistant", "content": "⏳ 正在生成..."})
 
     # 按钮保持可见但禁用，防止流式期间点击
-    loading = _get_loading_button_updates(
-        max(len(game_session.get("current_options", [])), MIN_OPTION_BUTTONS)
-    )
-    yield (
-        chat_history,
-        _format_status_panel(gs),
-        _get_scene_image_update(gs),
-        *loading,
-        game_session,
-    )
+    loading = _get_loading_button_updates(
+        max(len(game_session.get("current_options", [])), MIN_OPTION_BUTTONS)
+    )
+    yield (
+        chat_history,
+        _format_world_info_panel(gs),
+        _format_status_panel(gs),
+        _render_text_map(gs),
+        _get_scene_image_update(gs),
+        *loading,
+        game_session,
+    )
 
     # 3. 流式生成故事
-    generation_started = perf_counter()
-    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),
-                _get_scene_image_update(gs),
-                *loading,
-                game_session,
-            )
-        elif update["type"] == "final":
-            final_result = update
-
-    generation_latency_ms = (perf_counter() - generation_started) * 1000
+    generation_started = perf_counter()
+    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_world_info_panel(gs),
+                _format_status_panel(gs),
+                _render_text_map(gs),
+                _get_scene_image_update(gs),
+                *loading,
+                game_session,
+            )
+        elif update["type"] == "final":
+            final_result = update
+
+    generation_latency_ms = (perf_counter() - generation_started) * 1000
 
     # 4. 最终更新：完整文本 + 状态变化 + 选项 + 按钮
     if final_result:
         # ★ 安全兜底：强制确保恰好 3 个选项
-        options = _finalize_session_options(final_result.get("options", []))
-        game_session["current_options"] = options
+        options = _finalize_session_options(final_result.get("options", []))
+        game_session["current_options"] = options
 
         change_log = final_result.get("change_log", [])
         log_text = ""
@@ -503,113 +850,121 @@ def process_user_input(user_input: str, chat_history: list, game_session: dict):
             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)
-        _record_interaction_log(
-            game_session,
-            input_source="text_input",
-            user_input=user_input,
-            intent_result=intent,
-            output_text=full_message,
-            latency_ms=(perf_counter() - turn_started) * 1000,
-            nlu_latency_ms=nlu_latency_ms,
-            generation_latency_ms=generation_latency_ms,
-            final_result=final_result,
-        )
-
-        yield (
-            chat_history,
-            status_text,
-            _get_scene_image_update(gs),
-            *btn_updates,
-            game_session,
-        )
+        full_message = f"{final_result['story_text']}{log_text}{issues_text}"
+        chat_history[-1]["content"] = full_message
+
+        status_text = _format_status_panel(gs)
+        btn_updates = _get_button_updates(options)
+        _record_interaction_log(
+            game_session,
+            input_source="text_input",
+            user_input=user_input,
+            intent_result=intent,
+            output_text=full_message,
+            latency_ms=(perf_counter() - turn_started) * 1000,
+            nlu_latency_ms=nlu_latency_ms,
+            generation_latency_ms=generation_latency_ms,
+            final_result=final_result,
+        )
+
+        yield (
+            chat_history,
+            _format_world_info_panel(gs),
+            status_text,
+            _render_text_map(gs),
+            _get_scene_image_update(gs),
+            *btn_updates,
+            game_session,
+        )
     else:
         # ★ 兜底：final_result 为空，说明流式生成未产生 final 事件
         logger.warning("流式生成未产生 final 事件，使用兜底文本")
         fallback_text = "你环顾四周，思考着接下来该做什么..."
-        fallback_options = _finalize_session_options([])
-        game_session["current_options"] = fallback_options
-
-        options_text = _format_options(fallback_options)
-        full_message = f"{fallback_text}\n\n{options_text}"
-        fallback_result = {
-            "story_text": fallback_text,
-            "options": fallback_options,
-            "state_changes": {},
-            "change_log": [],
-            "consistency_issues": [],
-            "telemetry": {
-                "engine_mode": "app_fallback",
-                "used_fallback": True,
-                "fallback_reason": "missing_final_event",
-            },
-        }
-        chat_history[-1]["content"] = full_message
-
-        status_text = _format_status_panel(gs)
-        btn_updates = _get_button_updates(fallback_options)
-        _record_interaction_log(
-            game_session,
-            input_source="text_input",
-            user_input=user_input,
-            intent_result=intent,
-            output_text=full_message,
-            latency_ms=(perf_counter() - turn_started) * 1000,
-            nlu_latency_ms=nlu_latency_ms,
-            generation_latency_ms=generation_latency_ms,
-            final_result=fallback_result,
-        )
-
-        yield (
-            chat_history,
-            status_text,
-            _get_scene_image_update(gs),
-            *btn_updates,
-            game_session,
-        )
-        return
-
-
-def process_option_click(option_idx: int, chat_history: list, game_session: dict):
+        fallback_options = _finalize_session_options([])
+        game_session["current_options"] = fallback_options
+
+        full_message = fallback_text
+        fallback_result = {
+            "story_text": fallback_text,
+            "options": fallback_options,
+            "state_changes": {},
+            "change_log": [],
+            "consistency_issues": [],
+            "telemetry": {
+                "engine_mode": "app_fallback",
+                "used_fallback": True,
+                "fallback_reason": "missing_final_event",
+            },
+        }
+        chat_history[-1]["content"] = full_message
+
+        status_text = _format_status_panel(gs)
+        btn_updates = _get_button_updates(fallback_options)
+        _record_interaction_log(
+            game_session,
+            input_source="text_input",
+            user_input=user_input,
+            intent_result=intent,
+            output_text=full_message,
+            latency_ms=(perf_counter() - turn_started) * 1000,
+            nlu_latency_ms=nlu_latency_ms,
+            generation_latency_ms=generation_latency_ms,
+            final_result=fallback_result,
+        )
+
+        yield (
+            chat_history,
+            _format_world_info_panel(gs),
+            status_text,
+            _render_text_map(gs),
+            _get_scene_image_update(gs),
+            *btn_updates,
+            game_session,
+        )
+        return
+
+
+def process_option_click(option_idx: int, chat_history: list, game_session: dict):
     """
-    处理玩家点击选项按钮（流式版本）。
-
-    Args:
-        option_idx: 选项索引 (0-5)
-    """
-    if not game_session or not game_session.get("started"):
-        chat_history = chat_history or []
-        chat_history.append({"role": "assistant", "content": "请先点击「开始冒险」按钮！"})
-        loading = _get_loading_button_updates()
-        yield (
-            chat_history, "", gr.update(value=None, visible=False),
-            *loading,
-            game_session,
-        )
-        return
-
-    options = game_session.get("current_options", [])
-    if option_idx >= len(options):
-        btn_updates = _get_button_updates(options)
-        yield (
-            chat_history,
-            _format_status_panel(game_session["game_state"]),
-            _get_scene_image_update(game_session["game_state"]),
-            *btn_updates,
-            game_session,
-        )
-        return
-
-    selected_option = options[option_idx]
-    gs: GameState = game_session["game_state"]
-    story: StoryEngine = game_session["story"]
-    option_intent = _build_option_intent(selected_option)
-    turn_started = perf_counter()
+    处理玩家点击选项按钮（流式版本）。
+
+    Args:
+        option_idx: 选项索引 (0-5)
+    """
+    if not game_session or not game_session.get("started"):
+        chat_history = chat_history or []
+        chat_history.append({"role": "assistant", "content": "请先点击「开始冒险」按钮！"})
+        loading = _get_loading_button_updates()
+        yield (
+            chat_history,
+            _format_world_info_panel(None),
+            "",
+            "",
+            gr.update(value=None, visible=False),
+            *loading,
+            game_session,
+        )
+        return
+
+    options = game_session.get("current_options", [])
+    if option_idx >= len(options):
+        btn_updates = _get_button_updates(options)
+        yield (
+            chat_history,
+            _format_world_info_panel(game_session["game_state"]),
+            _format_status_panel(game_session["game_state"]),
+            _render_text_map(game_session["game_state"]),
+            _get_scene_image_update(game_session["game_state"]),
+            *btn_updates,
+            game_session,
+        )
+        return
+
+    selected_option = options[option_idx]
+    gs: GameState = game_session["game_state"]
+    story: StoryEngine = game_session["story"]
+    option_intent = _build_option_intent(selected_option)
+    turn_started = perf_counter()
 
     # 检查特殊选项：重新开始
     if selected_option.get("action_type") == "RESTART":
@@ -617,15 +972,20 @@ def process_option_click(option_idx: int, chat_history: list, game_session: dict
         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, _get_scene_image_update(game_session["game_state"]),
-            *loading,
-            game_session,
-        )
+        chat_history = [{"role": "assistant", "content": "⏳ 正在重新生成开场..."}]
+        world_info_text = _format_world_info_panel(game_session["game_state"])
+        status_text = _format_status_panel(game_session["game_state"])
+        loading = _get_loading_button_updates()
+
+        yield (
+            chat_history,
+            world_info_text,
+            status_text,
+            _render_text_map(game_session["game_state"]),
+            _get_scene_image_update(game_session["game_state"]),
+            *loading,
+            game_session,
+        )
 
         story_text = ""
         restart_final = None
@@ -634,11 +994,15 @@ def process_option_click(option_idx: int, chat_history: list, game_session: dict
             if update["type"] == "story_chunk":
                 story_text = update["text"]
                 chat_history[-1]["content"] = story_text
-                yield (
-                    chat_history, status_text, _get_scene_image_update(game_session["game_state"]),
-                    *loading,
-                    game_session,
-                )
+                yield (
+                    chat_history,
+                    world_info_text,
+                    status_text,
+                    _render_text_map(game_session["game_state"]),
+                    _get_scene_image_update(game_session["game_state"]),
+                    *loading,
+                    game_session,
+                )
             elif update["type"] == "final":
                 restart_final = update
 
@@ -650,75 +1014,84 @@ def process_option_click(option_idx: int, chat_history: list, game_session: dict
             restart_options = []
 
         # ★ 安全兜底：强制确保恰好 3 个选项
-        restart_options = _finalize_session_options(restart_options)
-        game_session["current_options"] = restart_options
-        options_text = _format_options(restart_options)
-        full_message = f"{story_text}\n\n{options_text}"
+        restart_options = _finalize_session_options(restart_options)
+        game_session["current_options"] = restart_options
+        full_message = story_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, _get_scene_image_update(game_session["game_state"]),
-            *btn_updates,
-            game_session,
-        )
-        return
+        yield (
+            chat_history,
+            _format_world_info_panel(game_session["game_state"]),
+            status_text,
+            _render_text_map(game_session["game_state"]),
+            _get_scene_image_update(game_session["game_state"]),
+            *btn_updates,
+            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点击「开始冒险」可以重新开始。"})
-        quit_buttons = _get_button_updates(
-            [
-                {"id": 1, "text": "重新开始", "action_type": "RESTART"},
-            ]
-        )
-        yield (
-            chat_history,
-            _format_status_panel(gs),
-            _get_scene_image_update(gs),
-            *quit_buttons,
-            game_session,
-        )
-        return
+        chat_history.append({"role": "assistant", "content": "感谢游玩 StoryWeaver！\n你的冒险到此结束，但故事永远不会真正终结...\n\n点击「开始冒险」可以重新开始。"})
+        quit_buttons = _get_button_updates(
+            [
+                {"id": 1, "text": "重新开始", "action_type": "RESTART"},
+            ]
+        )
+        yield (
+            chat_history,
+            _format_world_info_panel(gs),
+            _format_status_panel(gs),
+            _render_text_map(gs),
+            _get_scene_image_update(gs),
+            *quit_buttons,
+            game_session,
+        )
+        return
 
     # 正常选项处理：流式生成
     chat_history.append({"role": "user", "content": f"选择: {selected_option['text']}"})
     chat_history.append({"role": "assistant", "content": "⏳ 正在生成..."})
 
     # 按钮保持可见但禁用
-    loading = _get_loading_button_updates(max(len(options), MIN_OPTION_BUTTONS))
-    yield (
-        chat_history,
-        _format_status_panel(gs),
-        _get_scene_image_update(gs),
-        *loading,
-        game_session,
-    )
-
-    generation_started = perf_counter()
-    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),
-                _get_scene_image_update(gs),
-                *loading,
-                game_session,
-            )
-        elif update["type"] == "final":
-            final_result = update
-
-    generation_latency_ms = (perf_counter() - generation_started) * 1000
+    loading = _get_loading_button_updates(max(len(options), MIN_OPTION_BUTTONS))
+    yield (
+        chat_history,
+        _format_world_info_panel(gs),
+        _format_status_panel(gs),
+        _render_text_map(gs),
+        _get_scene_image_update(gs),
+        *loading,
+        game_session,
+    )
+
+    generation_started = perf_counter()
+    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_world_info_panel(gs),
+                _format_status_panel(gs),
+                _render_text_map(gs),
+                _get_scene_image_update(gs),
+                *loading,
+                game_session,
+            )
+        elif update["type"] == "final":
+            final_result = update
+
+    generation_latency_ms = (perf_counter() - generation_started) * 1000
 
     if final_result:
         # ★ 安全兜底：强制确保恰好 3 个选项
-        options = _finalize_session_options(final_result.get("options", []))
-        game_session["current_options"] = options
+        options = _finalize_session_options(final_result.get("options", []))
+        game_session["current_options"] = options
 
         change_log = final_result.get("change_log", [])
         log_text = ""
@@ -726,130 +1099,136 @@ def process_option_click(option_idx: int, chat_history: list, game_session: dict
             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)
-        _record_interaction_log(
-            game_session,
-            input_source="option_click",
-            user_input=selected_option.get("text", ""),
-            intent_result=option_intent,
-            output_text=full_message,
-            latency_ms=(perf_counter() - turn_started) * 1000,
-            generation_latency_ms=generation_latency_ms,
-            final_result=final_result,
-            selected_option=selected_option,
-        )
-
-        yield (
-            chat_history, status_text, _get_scene_image_update(gs),
-            *btn_updates,
-            game_session,
-        )
-    else:
+        full_message = f"{final_result['story_text']}{log_text}"
+        chat_history[-1]["content"] = full_message
+
+        status_text = _format_status_panel(gs)
+        btn_updates = _get_button_updates(options)
+        _record_interaction_log(
+            game_session,
+            input_source="option_click",
+            user_input=selected_option.get("text", ""),
+            intent_result=option_intent,
+            output_text=full_message,
+            latency_ms=(perf_counter() - turn_started) * 1000,
+            generation_latency_ms=generation_latency_ms,
+            final_result=final_result,
+            selected_option=selected_option,
+        )
+
+        yield (
+            chat_history,
+            _format_world_info_panel(gs),
+            status_text,
+            _render_text_map(gs),
+            _get_scene_image_update(gs),
+            *btn_updates,
+            game_session,
+        )
+    else:
         # ★ 兜底：final_result 为空，说明流式生成未产生 final 事件
         logger.warning("[选项点击] 流式生成未产生 final 事件，使用兜底文本")
         fallback_text = "你环顾四周，思考着接下来该做什么..."
-        fallback_options = _finalize_session_options([])
-        game_session["current_options"] = fallback_options
-
-        options_text = _format_options(fallback_options)
-        full_message = f"{fallback_text}\n\n{options_text}"
-        fallback_result = {
-            "story_text": fallback_text,
-            "options": fallback_options,
-            "state_changes": {},
-            "change_log": [],
-            "consistency_issues": [],
-            "telemetry": {
-                "engine_mode": "app_fallback",
-                "used_fallback": True,
-                "fallback_reason": "missing_final_event",
-            },
-        }
-        chat_history[-1]["content"] = full_message
-
-        status_text = _format_status_panel(gs)
-        btn_updates = _get_button_updates(fallback_options)
-        _record_interaction_log(
-            game_session,
-            input_source="option_click",
-            user_input=selected_option.get("text", ""),
-            intent_result=option_intent,
-            output_text=full_message,
-            latency_ms=(perf_counter() - turn_started) * 1000,
-            generation_latency_ms=generation_latency_ms,
-            final_result=fallback_result,
-            selected_option=selected_option,
-        )
-
-        yield (
-            chat_history, status_text, _get_scene_image_update(gs),
-            *btn_updates,
-            game_session,
-        )
+        fallback_options = _finalize_session_options([])
+        game_session["current_options"] = fallback_options
+
+        full_message = fallback_text
+        fallback_result = {
+            "story_text": fallback_text,
+            "options": fallback_options,
+            "state_changes": {},
+            "change_log": [],
+            "consistency_issues": [],
+            "telemetry": {
+                "engine_mode": "app_fallback",
+                "used_fallback": True,
+                "fallback_reason": "missing_final_event",
+            },
+        }
+        chat_history[-1]["content"] = full_message
+
+        status_text = _format_status_panel(gs)
+        btn_updates = _get_button_updates(fallback_options)
+        _record_interaction_log(
+            game_session,
+            input_source="option_click",
+            user_input=selected_option.get("text", ""),
+            intent_result=option_intent,
+            output_text=full_message,
+            latency_ms=(perf_counter() - turn_started) * 1000,
+            generation_latency_ms=generation_latency_ms,
+            final_result=fallback_result,
+            selected_option=selected_option,
+        )
+
+        yield (
+            chat_history,
+            _format_world_info_panel(gs),
+            status_text,
+            _render_text_map(gs),
+            _get_scene_image_update(gs),
+            *btn_updates,
+            game_session,
+        )
         return
 
 
-# ============================================================
-# UI 辅助函数
-# ============================================================
-
-
-MIN_OPTION_BUTTONS = 3
-MAX_OPTION_BUTTONS = 6
-
-# 兜底默认选项（当解析出的选项为空时使用）
-_FALLBACK_BUTTON_OPTIONS = [
-    {"id": 1, "text": "查看周围", "action_type": "EXPLORE"},
-    {"id": 2, "text": "等待一会", "action_type": "REST"},
-    {"id": 3, "text": "检查状态", "action_type": "EXPLORE"},
-]
-
-
-def _normalize_options(
-    options: list[dict],
-    *,
-    minimum: int = 0,
-    maximum: int = MAX_OPTION_BUTTONS,
-) -> list[dict]:
-    """
-    规范化选项列表：
-    - 至多保留 maximum 个选项
-    - 仅当 minimum > 0 时补充兜底项
-    - 始终重新编号
-    """
-    if not isinstance(options, list):
-        options = []
-
-    normalized = [opt for opt in options if isinstance(opt, dict)][:maximum]
-
-    for fb in _FALLBACK_BUTTON_OPTIONS:
-        if len(normalized) >= minimum:
-            break
-        if not any(o.get("text") == fb["text"] for o in normalized):
-            normalized.append(fb.copy())
-
-    while len(normalized) < minimum:
-        normalized.append({
-            "id": len(normalized) + 1,
-            "text": "继续探索",
-            "action_type": "EXPLORE",
-        })
-
-    for i, opt in enumerate(normalized[:maximum], 1):
-        if isinstance(opt, dict):
-            opt["id"] = i
-
-    return normalized[:maximum]
-
-
-def _finalize_session_options(options: list[dict]) -> list[dict]:
-    minimum = MIN_OPTION_BUTTONS if not options else 0
-    return _normalize_options(options, minimum=minimum)
+# ============================================================
+# UI 辅助函数
+# ============================================================
+
+
+MIN_OPTION_BUTTONS = 3
+MAX_OPTION_BUTTONS = 6
+
+# 兜底默认选项（当解析出的选项为空时使用）
+_FALLBACK_BUTTON_OPTIONS = [
+    {"id": 1, "text": "查看周围", "action_type": "EXPLORE"},
+    {"id": 2, "text": "等待一会", "action_type": "REST"},
+    {"id": 3, "text": "检查状态", "action_type": "EXPLORE"},
+]
+
+
+def _normalize_options(
+    options: list[dict],
+    *,
+    minimum: int = 0,
+    maximum: int = MAX_OPTION_BUTTONS,
+) -> list[dict]:
+    """
+    规范化选项列表：
+    - 至多保留 maximum 个选项
+    - 仅当 minimum > 0 时补充兜底项
+    - 始终重新编号
+    """
+    if not isinstance(options, list):
+        options = []
+
+    normalized = [opt for opt in options if isinstance(opt, dict)][:maximum]
+
+    for fb in _FALLBACK_BUTTON_OPTIONS:
+        if len(normalized) >= minimum:
+            break
+        if not any(o.get("text") == fb["text"] for o in normalized):
+            normalized.append(fb.copy())
+
+    while len(normalized) < minimum:
+        normalized.append({
+            "id": len(normalized) + 1,
+            "text": "继续探索",
+            "action_type": "EXPLORE",
+        })
+
+    for i, opt in enumerate(normalized[:maximum], 1):
+        if isinstance(opt, dict):
+            opt["id"] = i
+
+    return normalized[:maximum]
+
+
+def _finalize_session_options(options: list[dict]) -> list[dict]:
+    minimum = MIN_OPTION_BUTTONS if not options else 0
+    return _normalize_options(options, minimum=minimum)
 
 
 def _format_options(options: list[dict]) -> str:
@@ -869,56 +1248,56 @@ def _format_options(options: list[dict]) -> str:
     return "\n".join(lines)
 
 
-def _get_loading_button_updates(visible_count: int = MIN_OPTION_BUTTONS) -> list:
-    """返回加载中占位按钮更新，支持最多 6 个选项槽位。"""
-    visible_count = max(0, min(int(visible_count or 0), MAX_OPTION_BUTTONS))
-    updates = []
-    for index in range(MAX_OPTION_BUTTONS):
-        updates.append(
-            gr.update(
-                value="...",
-                visible=index < visible_count,
-                interactive=False,
-            )
-        )
-    return updates
-
-
-def _get_button_updates(options: list[dict]) -> list:
-    """从选项列表生成按钮更新，始终返回 6 个槽位。"""
-    options = _normalize_options(options, minimum=0)
-
-    updates = []
-    for i in range(MAX_OPTION_BUTTONS):
-        opt = options[i] if i < len(options) else None
-        if isinstance(opt, dict):
-            text = opt.get("text", "...")
-            visible = True
-        else:
-            text = "..."
-            visible = False
-        updates.append(gr.update(value=text, visible=visible, interactive=visible))
-    return updates
-
-
-def _format_status_panel(gs: GameState) -> str:
-    """格式化状态面板文本（双列 HTML 布局，减少滚动）"""
-    p = gs.player
-    w = gs.world
-    effective_stats = gs.get_effective_player_stats()
-    equipment_bonuses = gs.get_equipment_stat_bonuses()
-    env_snapshot = gs.get_environment_snapshot(limit=3)
-    survival_snapshot = gs.get_survival_state_snapshot()
-    scene_summary = gs.get_scene_summary().replace("\n", "<br>")
-    clock_display = gs.get_clock_display()
-
-    # 属性进度条
-    hp_bar = _progress_bar(p.hp, p.max_hp, "HP")
-    mp_bar = _progress_bar(p.mp, p.max_mp, "MP")
-    stamina_bar = _progress_bar(p.stamina, p.max_stamina, "体力")
-    hunger_bar = _progress_bar(p.hunger, 100, "饱食")
-    sanity_bar = _progress_bar(p.sanity, 100, "理智")
-    morale_bar = _progress_bar(p.morale, 100, "士气")
+def _get_loading_button_updates(visible_count: int = MIN_OPTION_BUTTONS) -> list:
+    """返回加载中占位按钮更新，支持最多 6 个选项槽位。"""
+    visible_count = max(0, min(int(visible_count or 0), MAX_OPTION_BUTTONS))
+    updates = []
+    for index in range(MAX_OPTION_BUTTONS):
+        updates.append(
+            gr.update(
+                value="...",
+                visible=index < visible_count,
+                interactive=False,
+            )
+        )
+    return updates
+
+
+def _get_button_updates(options: list[dict]) -> list:
+    """从选项列表生成按钮更新，始终返回 6 个槽位。"""
+    options = _normalize_options(options, minimum=0)
+
+    updates = []
+    for i in range(MAX_OPTION_BUTTONS):
+        opt = options[i] if i < len(options) else None
+        if isinstance(opt, dict):
+            text = opt.get("text", "...")
+            visible = True
+        else:
+            text = "..."
+            visible = False
+        updates.append(gr.update(value=text, visible=visible, interactive=visible))
+    return updates
+
+
+def _format_status_panel(gs: GameState) -> str:
+    """格式化状态面板文本（双列 HTML 布局，减少滚动）"""
+    p = gs.player
+    w = gs.world
+    effective_stats = gs.get_effective_player_stats()
+    equipment_bonuses = gs.get_equipment_stat_bonuses()
+    env_snapshot = gs.get_environment_snapshot(limit=3)
+    survival_snapshot = gs.get_survival_state_snapshot()
+    scene_summary = gs.get_scene_summary().replace("\n", "<br>")
+    clock_display = gs.get_clock_display()
+
+    # 属性进度条
+    hp_bar = _progress_bar(p.hp, p.max_hp, "HP")
+    mp_bar = _progress_bar(p.mp, p.max_mp, "MP")
+    stamina_bar = _progress_bar(p.stamina, p.max_stamina, "体力")
+    hunger_bar = _progress_bar(p.hunger, 100, "饱食")
+    sanity_bar = _progress_bar(p.sanity, 100, "理智")
+    morale_bar = _progress_bar(p.morale, 100, "士气")
 
     # 装备
     slot_names = {
@@ -926,26 +1305,26 @@ def _format_status_panel(gs: GameState) -> str:
         "helmet": "头盔", "boots": "靴子",
     }
     equip_lines = []
-    for slot, item in p.equipment.items():
-        equip_lines.append(f"{slot_names.get(slot, slot)}: {item or '无'}")
-    equip_text = "<br>".join(equip_lines)
-
-    def render_stat(stat_key: str, label: str) -> str:
-        base_value = int(getattr(p, stat_key))
-        bonus_value = int(equipment_bonuses.get(stat_key, 0))
-        effective_value = int(effective_stats.get(stat_key, base_value))
-        if bonus_value > 0:
-            return f"{label}: {effective_value} <span style='color:#4a6;'>(+{bonus_value} 装备)</span>"
-        if bonus_value < 0:
-            return f"{label}: {effective_value} <span style='color:#b44;'>({bonus_value} 装备)</span>"
-        return f"{label}: {base_value}"
-
-    def badge(text: str, bg: str, fg: str = "#1f2937") -> str:
-        return (
-            f"<span style='display:inline-block;margin:0 6px 6px 0;padding:3px 10px;"
-            f"border-radius:999px;background:{bg};color:{fg};font-size:0.8em;"
-            f"font-weight:600;'>{text}</span>"
-        )
+    for slot, item in p.equipment.items():
+        equip_lines.append(f"{slot_names.get(slot, slot)}: {item or '无'}")
+    equip_text = "<br>".join(equip_lines)
+
+    def render_stat(stat_key: str, label: str) -> str:
+        base_value = int(getattr(p, stat_key))
+        bonus_value = int(equipment_bonuses.get(stat_key, 0))
+        effective_value = int(effective_stats.get(stat_key, base_value))
+        if bonus_value > 0:
+            return f"{label}: {effective_value} <span style='color:#4a6;'>(+{bonus_value} 装备)</span>"
+        if bonus_value < 0:
+            return f"{label}: {effective_value} <span style='color:#b44;'>({bonus_value} 装备)</span>"
+        return f"{label}: {base_value}"
+
+    def badge(text: str, bg: str, fg: str = "#1f2937") -> str:
+        return (
+            f"<span style='display:inline-block;margin:0 6px 6px 0;padding:3px 10px;"
+            f"border-radius:999px;background:{bg};color:{fg};font-size:0.8em;"
+            f"font-weight:600;'>{text}</span>"
+        )
 
     # 状态效果
     if p.status_effects:
@@ -958,65 +1337,65 @@ def _format_status_panel(gs: GameState) -> str:
     # 背包
     if p.inventory:
         inventory_text = "<br>".join(p.inventory)
-    else:
-        inventory_text = "空"
-
-    weather_colors = {
-        "晴朗": "#fef3c7",
-        "多云": "#e5e7eb",
-        "小雨": "#dbeafe",
-        "浓雾": "#e0e7ff",
-        "暴风雨": "#c7d2fe",
-        "大雪": "#f3f4f6",
-    }
-    light_colors = {
-        "明亮": "#fde68a",
-        "柔和": "#fcd34d",
-        "昏暗": "#cbd5e1",
-        "幽暗": "#94a3b8",
-        "漆黑": "#334155",
-    }
-    danger_level = int(env_snapshot.get("danger_level", 0))
-    if danger_level >= 7:
-        danger_badge = badge(f"危险 {danger_level}/10", "#fecaca", "#7f1d1d")
-    elif danger_level >= 4:
-        danger_badge = badge(f"危险 {danger_level}/10", "#fed7aa", "#9a3412")
-    else:
-        danger_badge = badge(f"危险 {danger_level}/10", "#dcfce7", "#166534")
-
-    env_badges = "".join(
-        [
-            badge(f"天气 {w.weather}", weather_colors.get(w.weather, "#e5e7eb")),
-            badge(
-                f"光照 {w.light_level}",
-                light_colors.get(w.light_level, "#e5e7eb"),
-                "#0f172a" if w.light_level not in {"幽暗", "漆黑"} else "#f8fafc",
-            ),
-            danger_badge,
-            badge(f"场景 {env_snapshot.get('location_type', 'unknown')}", "#ede9fe", "#4c1d95"),
-        ]
-    )
-
-    recent_env_events = env_snapshot.get("recent_events", [])
-    if recent_env_events:
-        latest_event = recent_env_events[-1]
-        latest_event_html = (
-            f"<div style='padding:8px 10px;border-radius:10px;background:#f8fafc;"
-            f"border:1px solid #dbeafe;margin-bottom:6px;'>"
-            f"<b>{latest_event.get('title', '环境事件')}</b>"
-            f"<br><span style='font-size:0.82em;color:#475569;'>{latest_event.get('description', '')}</span>"
-            f"</div>"
-        )
-        recent_event_lines = "<br>".join(
-            f"- {event.get('title', '环境事件')}"
-            for event in reversed(recent_env_events[-3:])
-        )
-    else:
-        latest_event_html = (
-            "<div style='padding:8px 10px;border-radius:10px;background:#f8fafc;"
-            "border:1px dashed #cbd5e1;color:#64748b;'>本回合暂无显式环境事件</div>"
-        )
-        recent_event_lines = "无"
+    else:
+        inventory_text = "空"
+
+    weather_colors = {
+        "晴朗": "#fef3c7",
+        "多云": "#e5e7eb",
+        "小雨": "#dbeafe",
+        "浓雾": "#e0e7ff",
+        "暴风雨": "#c7d2fe",
+        "大雪": "#f3f4f6",
+    }
+    light_colors = {
+        "明亮": "#fde68a",
+        "柔和": "#fcd34d",
+        "昏暗": "#cbd5e1",
+        "幽暗": "#94a3b8",
+        "漆黑": "#334155",
+    }
+    danger_level = int(env_snapshot.get("danger_level", 0))
+    if danger_level >= 7:
+        danger_badge = badge(f"危险 {danger_level}/10", "#fecaca", "#7f1d1d")
+    elif danger_level >= 4:
+        danger_badge = badge(f"危险 {danger_level}/10", "#fed7aa", "#9a3412")
+    else:
+        danger_badge = badge(f"危险 {danger_level}/10", "#dcfce7", "#166534")
+
+    env_badges = "".join(
+        [
+            badge(f"天气 {w.weather}", weather_colors.get(w.weather, "#e5e7eb")),
+            badge(
+                f"光照 {w.light_level}",
+                light_colors.get(w.light_level, "#e5e7eb"),
+                "#0f172a" if w.light_level not in {"幽暗", "漆黑"} else "#f8fafc",
+            ),
+            danger_badge,
+            badge(f"场景 {env_snapshot.get('location_type', 'unknown')}", "#ede9fe", "#4c1d95"),
+        ]
+    )
+
+    recent_env_events = env_snapshot.get("recent_events", [])
+    if recent_env_events:
+        latest_event = recent_env_events[-1]
+        latest_event_html = (
+            f"<div style='padding:8px 10px;border-radius:10px;background:#f8fafc;"
+            f"border:1px solid #dbeafe;margin-bottom:6px;'>"
+            f"<b>{latest_event.get('title', '环境事件')}</b>"
+            f"<br><span style='font-size:0.82em;color:#475569;'>{latest_event.get('description', '')}</span>"
+            f"</div>"
+        )
+        recent_event_lines = "<br>".join(
+            f"- {event.get('title', '环境事件')}"
+            for event in reversed(recent_env_events[-3:])
+        )
+    else:
+        latest_event_html = (
+            "<div style='padding:8px 10px;border-radius:10px;background:#f8fafc;"
+            "border:1px dashed #cbd5e1;color:#64748b;'>本回合暂无显式环境事件</div>"
+        )
+        recent_event_lines = "无"
 
     # 活跃任务（完整展示：描述、子目标、奖励、来源）
     active_quests = [q for q in w.quests.values() if q.status == "active"]
@@ -1047,10 +1426,10 @@ def _format_status_panel(gs: GameState) -> str:
 
             block = (
                 f"<details open><summary><b>{tag} {q.title}</b>（{done}/{total}）</summary>"
-                f"<span style='font-size:0.82em;color:#888;'>来源: {q.giver_npc or '未知'}</span><br>"
-                f"<span style='font-size:0.82em;'>{q.description}</span>"
+                f"<span style='font-size:0.9em;color:#666;'>来源: {q.giver_npc or '未知'}</span><br>"
+                f"<span style='font-size:0.9em;'>{q.description}</span>"
                 f"{obj_lines}"
-                f"<br><span style='font-size:0.82em;color:#4a6;'>奖励: {reward_str}</span>"
+                f"<br><span style='font-size:0.9em;color:#2f7a4a;'>奖励: {reward_str}</span>"
                 f"</details>"
             )
             quest_blocks.append(block)
@@ -1068,31 +1447,30 @@ def _format_status_panel(gs: GameState) -> str:
 <div>
 <h4 style="margin:4px 0 2px 0;">🩸 生命与状态</h4>
 <span style="font-size:0.85em;">
-{hp_bar}<br>
-{mp_bar}<br>
-{stamina_bar}<br>
-{hunger_bar}<br>
-{sanity_bar}<br>
-{morale_bar}
-</span>
-</div>
-
-<div>
-<h4 style="margin:4px 0 2px 0;">⚔️ 战斗属性</h4>
-<span style="font-size:0.85em;">
-{render_stat("attack", "攻击")}<br>
-{render_stat("defense", "防御")}<br>
-{render_stat("speed", "速度")}<br>
-{render_stat("luck", "幸运")}<br>
-{render_stat("perception", "感知")}
-</span>
-</div>
+{hp_bar}<br>
+{mp_bar}<br>
+{stamina_bar}<br>
+{hunger_bar}<br>
+{sanity_bar}<br>
+{morale_bar}
+</span>
+</div>
 
 <div>
-<h4 style="margin:4px 0 2px 0;">💰 资源</h4>
+<h4 style="margin:4px 0 2px 0;">🎒 背包</h4>
 <span style="font-size:0.85em;">
-金币: {p.gold}<br>
-善恶值: {p.karma}
+{inventory_text}
+</span>
+</div>
+
+<div>
+<h4 style="margin:4px 0 2px 0;">⚔️ 战斗属性</h4>
+<span style="font-size:0.85em;">
+{render_stat("attack", "攻击")}<br>
+{render_stat("defense", "防御")}<br>
+{render_stat("speed", "速度")}<br>
+{render_stat("luck", "幸运")}<br>
+{render_stat("perception", "感知")}
 </span>
 </div>
 
@@ -1104,56 +1482,72 @@ def _format_status_panel(gs: GameState) -> str:
 </div>
 
 <div>
-<h4 style="margin:4px 0 2px 0;">✨ 状态效果</h4>
+<h4 style="margin:4px 0 2px 0;">💰 资源</h4>
 <span style="font-size:0.85em;">
-{effect_lines}
+金币: {p.gold}<br>
+善恶值: {p.karma}
 </span>
 </div>
 
-<div>
-<h4 style="margin:4px 0 2px 0;">🎒 背包</h4>
-<span style="font-size:0.85em;">
-{inventory_text}
-</span>
-</div>
-
-<div style="grid-column: 1 / -1;">
-<h4 style="margin:4px 0 2px 0;">🧭 当前场景信息</h4>
-<div style="font-size:0.85em;line-height:1.5;padding:8px 10px;border-radius:12px;background:#fff7ed;border:1px solid #fed7aa;">
-{env_badges}
-<div style="margin:6px 0 8px 0;color:#475569;">
-时间 {clock_display} | 场景 {w.current_scene} | 状态系数 {survival_snapshot.get('combined_multiplier', 1.0)}
-</div>
-{latest_event_html}
-<div style="margin-top:8px;">{scene_summary}</div>
-<div style="margin-top:6px;color:#475569;">最近环境事件: {recent_event_lines}</div>
-</div>
-</div>
-
-<div style="grid-column: 1 / -1;">
-<h4 style="margin:4px 0 2px 0;">📜 任务</h4>
-<span style="font-size:0.85em;">
-{quest_text}
-</span>
-</div>
-
 <div>
-<h4 style="margin:4px 0 2px 0;">🌍 世界信息</h4>
+<h4 style="margin:4px 0 2px 0;">✨ 状态效果</h4>
 <span style="font-size:0.85em;">
-位置: {w.current_scene}<br>
-时间: 第{w.day_count}天 {w.time_of_day} ({clock_display})<br>
-天气: {w.weather}<br>
-光照: {w.light_level}<br>
-季节: {w.season}<br>
-回合: {gs.turn}
-</span>
-</div>
+{effect_lines}
+</span>
+</div>
+
+<div style="grid-column: 1 / -1;">
+<h4 style="margin:4px 0 2px 0;">📜 任务</h4>
+<span style="font-size:0.9em;line-height:1.55;">
+{quest_text}
+</span>
+</div>
 
+<div style="grid-column: 1 / -1;">
+<h4 style="margin:4px 0 2px 0;">🧭 当前场景信息</h4>
+<div style="font-size:0.85em;line-height:1.5;padding:8px 10px;border-radius:12px;background:#fff7ed;border:1px solid #fed7aa;">
+{env_badges}
+<div style="margin:6px 0 8px 0;color:#475569;">
+时间 {clock_display} | 场景 {w.current_scene} | 状态系数 {survival_snapshot.get('combined_multiplier', 1.0)}
+</div>
+{latest_event_html}
+<div style="margin-top:8px;">{scene_summary}</div>
+<div style="margin-top:6px;color:#475569;">最近环境事件: {recent_event_lines}</div>
+</div>
+</div>
 </div>
 </div>"""
     return status
 
 
+def _format_world_info_panel(gs: GameState | None) -> str:
+    """格式化世界信息面板（放在故事框上方）。"""
+    if gs is None:
+        return "🌍 **世界信息**：未开始冒险"
+
+    w = gs.world
+    if hasattr(gs, "get_clock_display"):
+        clock_display = gs.get_clock_display()
+    else:
+        minute_of_day = int(getattr(w, "time_progress_units", 0)) * 10 % (24 * 60)
+        clock_display = f"{minute_of_day // 60:02d}:{minute_of_day % 60:02d}"
+
+    current_scene = getattr(w, "current_scene", "未知地点")
+    day_count = getattr(w, "day_count", 1)
+    time_of_day = getattr(w, "time_of_day", "未知时段")
+    weather = getattr(w, "weather", "未知")
+    light_level = getattr(w, "light_level", "未知")
+    season = getattr(w, "season", "未知")
+
+    return (
+        "🌍 **世界���息**："
+        f"位置 {current_scene} ｜ "
+        f"第{day_count}天 {time_of_day}（{clock_display}） ｜ "
+        f"天气 {weather} ｜ 光照 {light_level} ｜ "
+        f"季节 {season} ｜ 回合 {getattr(gs, 'turn', 0)}"
+    )
+
+
 def _progress_bar(current: int, maximum: int, label: str, length: int = 10) -> str:
     """生成文本进度条"""
     ratio = current / maximum if maximum > 0 else 0
@@ -1168,13 +1562,13 @@ def _progress_bar(current: int, maximum: int, label: str, length: int = 10) -> s
 # ============================================================
 
 
-def build_app() -> gr.Blocks:
-    """构建 Gradio 界面"""
-
-    with gr.Blocks(
-        title="StoryWeaver - 交互式叙事系统",
-    ) as app:
-        app.css = APP_UI_CSS
+def build_app() -> gr.Blocks:
+    """构建 Gradio 界面"""
+
+    with gr.Blocks(
+        title="StoryWeaver - 交互式叙事系统",
+    ) as app:
+        app.css = APP_UI_CSS
 
         gr.Markdown(
             """
@@ -1210,60 +1604,70 @@ def build_app() -> gr.Blocks:
                         scale=2,
                     )
 
+                world_info_panel = gr.Markdown(
+                    value=_format_world_info_panel(None),
+                )
+
                 # 聊天窗口
                 chatbot = gr.Chatbot(
                     label="故事",
                     height=480,
                 )
 
-                # 选项按钮（最多 6 个，分两行显示）
-                with gr.Column():
-                    with gr.Row():
-                        option_btn_1 = gr.Button(
-                            "...",
-                            visible=True,
-                            interactive=False,
-                            elem_classes=["option-btn"],
-                        )
-                        option_btn_2 = gr.Button(
-                            "...",
-                            visible=True,
-                            interactive=False,
-                            elem_classes=["option-btn"],
-                        )
-                        option_btn_3 = gr.Button(
-                            "...",
-                            visible=True,
-                            interactive=False,
-                            elem_classes=["option-btn"],
-                        )
-                    with gr.Row():
-                        option_btn_4 = gr.Button(
-                            "...",
-                            visible=False,
-                            interactive=False,
-                            elem_classes=["option-btn"],
-                        )
-                        option_btn_5 = gr.Button(
-                            "...",
-                            visible=False,
-                            interactive=False,
-                            elem_classes=["option-btn"],
-                        )
-                        option_btn_6 = gr.Button(
-                            "...",
-                            visible=False,
-                            interactive=False,
-                            elem_classes=["option-btn"],
-                        )
-                option_buttons = [
-                    option_btn_1,
-                    option_btn_2,
-                    option_btn_3,
-                    option_btn_4,
-                    option_btn_5,
-                    option_btn_6,
-                ]
+                location_map_panel = gr.Markdown(
+                    elem_classes=["scene-card", "status-panel"],
+                    value="地图关系图\n（未开始）",
+                    label="地图",
+                )
+
+                # 选项按钮（最多 6 个，分两行显示）
+                with gr.Column():
+                    with gr.Row():
+                        option_btn_1 = gr.Button(
+                            "...",
+                            visible=True,
+                            interactive=False,
+                            elem_classes=["option-btn"],
+                        )
+                        option_btn_2 = gr.Button(
+                            "...",
+                            visible=True,
+                            interactive=False,
+                            elem_classes=["option-btn"],
+                        )
+                        option_btn_3 = gr.Button(
+                            "...",
+                            visible=True,
+                            interactive=False,
+                            elem_classes=["option-btn"],
+                        )
+                    with gr.Row():
+                        option_btn_4 = gr.Button(
+                            "...",
+                            visible=False,
+                            interactive=False,
+                            elem_classes=["option-btn"],
+                        )
+                        option_btn_5 = gr.Button(
+                            "...",
+                            visible=False,
+                            interactive=False,
+                            elem_classes=["option-btn"],
+                        )
+                        option_btn_6 = gr.Button(
+                            "...",
+                            visible=False,
+                            interactive=False,
+                            elem_classes=["option-btn"],
+                        )
+                option_buttons = [
+                    option_btn_1,
+                    option_btn_2,
+                    option_btn_3,
+                    option_btn_4,
+                    option_btn_5,
+                    option_btn_6,
+                ]
 
                 # 自由输入
                 with gr.Row():
@@ -1275,100 +1679,100 @@ def build_app() -> gr.Blocks:
                     )
                     send_btn = gr.Button("发送", variant="primary", scale=1)
 
-            # ==================
-            # 右侧：状态面板
-            # ==================
-            with gr.Column(scale=2, min_width=250, elem_classes=["scene-sidebar"]):
-                scene_image = gr.Image(
-                    value=None,
-                    type="filepath",
-                    label="场景画面",
-                    show_label=False,
-                    container=False,
-                    interactive=False,
-                    height=260,
-                    buttons=[],
-                    visible=False,
-                    elem_classes=["scene-card", "scene-image"],
-                )
-                status_panel = gr.Markdown(
-                    elem_classes=["scene-card", "status-panel"],
-                    value="## 等待开始...\n\n请输入角色名称并点击「开始冒险」",
-                    label="角色状态",
-                )
+            # ==================
+            # 右侧：状态面板
+            # ==================
+            with gr.Column(scale=2, min_width=320, elem_classes=["scene-sidebar"]):
+                scene_image = gr.Image(
+                    value=None,
+                    type="filepath",
+                    label="场景画面",
+                    show_label=False,
+                    container=False,
+                    interactive=False,
+                    height=260,
+                    buttons=[],
+                    visible=False,
+                    elem_classes=["scene-card", "scene-image"],
+                )
+                status_panel = gr.Markdown(
+                    elem_classes=["scene-card", "status-panel"],
+                    value="## 等待开始...\n\n请输入角色名称并点击「开始冒险」",
+                    label="角色状态",
+                )
 
         # ============================================================
         # 事件绑定
         # ============================================================
 
         # 开始游戏
-        start_btn.click(
-            fn=start_game,
-            inputs=[player_name_input, game_session],
-            outputs=[
-                chatbot, status_panel, scene_image,
-                *option_buttons,
-                game_session, user_input,
-            ],
-        )
+        start_btn.click(
+            fn=start_game,
+            inputs=[player_name_input, game_session],
+            outputs=[
+                chatbot, world_info_panel, status_panel, location_map_panel, scene_image,
+                *option_buttons,
+                game_session, user_input,
+            ],
+        )
 
         # 重启冒险
-        restart_btn.click(
-            fn=restart_game,
-            inputs=[],
-            outputs=[
-                chatbot, status_panel, scene_image,
-                *option_buttons,
-                game_session, user_input, player_name_input,
-            ],
-        )
+        restart_btn.click(
+            fn=restart_game,
+            inputs=[],
+            outputs=[
+                chatbot, world_info_panel, status_panel, location_map_panel, scene_image,
+                *option_buttons,
+                game_session, user_input, player_name_input,
+            ],
+        )
 
         # 文本输入发送
-        send_btn.click(
-            fn=process_user_input,
-            inputs=[user_input, chatbot, game_session],
-            outputs=[
-                chatbot, status_panel, scene_image,
-                *option_buttons,
-                game_session,
-            ],
-        ).then(
+        send_btn.click(
+            fn=process_user_input,
+            inputs=[user_input, chatbot, game_session],
+            outputs=[
+                chatbot, world_info_panel, status_panel, location_map_panel, scene_image,
+                *option_buttons,
+                game_session,
+            ],
+        ).then(
             fn=lambda: "",
             outputs=[user_input],
         )
 
         # 回车发送
-        user_input.submit(
-            fn=process_user_input,
-            inputs=[user_input, chatbot, game_session],
-            outputs=[
-                chatbot, status_panel, scene_image,
-                *option_buttons,
-                game_session,
-            ],
-        ).then(
+        user_input.submit(
+            fn=process_user_input,
+            inputs=[user_input, chatbot, game_session],
+            outputs=[
+                chatbot, world_info_panel, status_panel, location_map_panel, scene_image,
+                *option_buttons,
+                game_session,
+            ],
+        ).then(
             fn=lambda: "",
             outputs=[user_input],
         )
 
         # 选项按钮点击（需要使用 yield from 的生成器包装函数，
         # 使 Gradio 能正确识别为流式输出）
-        def _make_option_click_handler(index: int):
-            def _handler(ch, gs):
-                yield from process_option_click(index, ch, gs)
-
-            return _handler
-
-        for index, option_button in enumerate(option_buttons):
-            option_button.click(
-                fn=_make_option_click_handler(index),
-                inputs=[chatbot, game_session],
-                outputs=[
-                    chatbot, status_panel, scene_image,
-                    *option_buttons,
-                    game_session,
-                ],
-            )
+        def _make_option_click_handler(index: int):
+            def _handler(ch, gs):
+                yield from process_option_click(index, ch, gs)
+
+            return _handler
+
+        for index, option_button in enumerate(option_buttons):
+            option_button.click(
+                fn=_make_option_click_handler(index),
+                inputs=[chatbot, game_session],
+                outputs=[
+                        chatbot, world_info_panel, status_panel, location_map_panel, scene_image,
+                    *option_buttons,
+                    game_session,
+                ],
+            )
 
     return app
 
@@ -1389,5 +1793,5 @@ if __name__ == "__main__":
             primary_hue="emerald",
             secondary_hue="blue",
         ),
-        css=APP_UI_CSS,
-    )
+        css=APP_UI_CSS,
+    )

combat_engine.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import random
+from typing import Any
+
+
+MONSTER_DB: dict[str, dict[str, int]] = {
+    "哥布林": {"hp": 20, "attack": 5, "defense": 2, "difficulty": 1},
+    "森林狼": {"hp": 40, "attack": 15, "defense": 5, "difficulty": 2},
+    "远古巨龙": {"hp": 500, "attack": 100, "defense": 80, "difficulty": 10},
+    "default": {"hp": 30, "attack": 10, "defense": 5, "difficulty": 1},
+}
+
+
+def _difficulty_scale(game_state: Any | None) -> float:
+    if game_state is None:
+        return 1.0
+    diff_name = str(getattr(game_state, "difficulty", "normal")).lower()
+    return {"easy": 0.9, "normal": 1.0, "hard": 1.2}.get(diff_name, 1.0)
+
+
+def _current_location_danger(game_state: Any | None) -> int:
+    if game_state is None:
+        return 1
+    player = getattr(game_state, "player", None)
+    world = getattr(game_state, "world", None)
+    if player is None or world is None:
+        return 1
+    location_name = str(getattr(player, "location", ""))
+    location = getattr(world, "locations", {}).get(location_name)
+    if location is None:
+        return 1
+    try:
+        return max(1, int(getattr(location, "danger_level", 1)))
+    except Exception:
+        return 1
+
+
+def get_monster_profile(monster_name: str, game_state: Any | None = None) -> dict[str, int]:
+    normalized_name = str(monster_name or "").strip()
+    profile = MONSTER_DB.get(normalized_name)
+    if profile is not None:
+        return dict(profile)
+
+    base = dict(MONSTER_DB["default"])
+    location_danger = _current_location_danger(game_state)
+    diff_scale = _difficulty_scale(game_state)
+
+    generated_difficulty = max(1, int(round(base["difficulty"] + (location_danger - 1) * 0.6)))
+    generated_attack = max(1, int(round(base["attack"] * diff_scale + location_danger * 2)))
+    generated_defense = max(1, int(round(base["defense"] * diff_scale + location_danger)))
+    generated_hp = max(1, int(round(base["hp"] * diff_scale + location_danger * 10)))
+
+    return {
+        "hp": generated_hp,
+        "attack": generated_attack,
+        "defense": generated_defense,
+        "difficulty": generated_difficulty,
+    }
+
+
+def resolve_combat(
+    player_state: Any,
+    monster_name: str,
+    *,
+    game_state: Any | None = None,
+    rng: random.Random | None = None,
+) -> dict[str, Any]:
+    active_rng = rng or random
+    monster = get_monster_profile(monster_name, game_state=game_state)
+
+    player_level = max(1, int(getattr(player_state, "level", 1)))
+    player_attack = max(1, int(getattr(player_state, "attack_power", getattr(player_state, "attack", 1))))
+    player_defense = max(0, int(getattr(player_state, "defense_power", getattr(player_state, "defense", 0))))
+
+    player_power = player_attack + player_level * 2
+    monster_power = int(monster["defense"]) + int(monster["difficulty"]) * 3
+    outcome = "win" if player_power >= monster_power else "lose"
+
+    random_float = float(active_rng.uniform(0.0, 3.0))
+    base_hp_loss = max(1, int(round(int(monster["attack"]) - player_defense - random_float)))
+    if outcome == "lose":
+        base_hp_loss = max(base_hp_loss + int(monster["difficulty"]) * 2, int(round(base_hp_loss * 1.4)))
+
+    if outcome == "win":
+        message = f"你击败了{monster_name}，但仍受了些伤。"
+    else:
+        message = f"你不敌{monster_name}，被迫败退。"
+
+    return {
+        "outcome": outcome,
+        "player_hp_loss": int(base_hp_loss),
+        "monster_name": str(monster_name),
+        "message": message,
+        "player_power": int(player_power),
+        "monster_power": int(monster_power),
+    }

nlu_engine.py

@@ -21,6 +21,7 @@ import re
 import logging
 from typing import Optional
 
+from demo_rules import build_scene_actions
 from utils import safe_json_call, DEFAULT_MODEL
 from state_manager import GameState
 
@@ -117,14 +118,14 @@ class NLUEngine:
                 "raw_input": "我想用剑攻击那个哥布林"
             }
         """
-        if not user_input or not user_input.strip():
-            return {
-                "intent": "EXPLORE",
-                "target": None,
-                "details": "玩家沉默不语",
-                "raw_input": "",
-                "parser_source": "empty_input",
-            }
+        if not user_input or not user_input.strip():
+            return {
+                "intent": "EXPLORE",
+                "target": None,
+                "details": "玩家沉默不语",
+                "raw_input": "",
+                "parser_source": "empty_input",
+            }
 
         user_input = user_input.strip()
         logger.info(f"NLU 解析输入: '{user_input}'")
@@ -133,17 +134,17 @@ class NLUEngine:
         result = self._llm_parse(user_input)
 
         # 如果 LLM 解析失败，使用关键词降级
-        if result is None:
-            logger.warning("LLM 解析失败，使用关键词降级")
-            result = self._keyword_fallback(user_input)
-
-        result = self._apply_intent_postprocessing(result, user_input)
-
-        # 附加原始输入
-        result["raw_input"] = user_input
-
-        logger.info(f"NLU 解析结果: {result}")
-        return result
+        if result is None:
+            logger.warning("LLM 解析失败，使用关键词降级")
+            result = self._keyword_fallback(user_input)
+
+        result = self._apply_intent_postprocessing(result, user_input)
+
+        # 附加原始输入
+        result["raw_input"] = user_input
+
+        logger.info(f"NLU 解析结果: {result}")
+        return result
 
     def _llm_parse(self, user_input: str) -> Optional[dict]:
         """
@@ -171,17 +172,17 @@ class NLUEngine:
             max_retries=2,
         )
 
-        if result and isinstance(result, dict) and "intent" in result:
-            # 验证意图类型合法
-            valid_intents = {
-                "ATTACK", "TALK", "MOVE", "EXPLORE", "USE_ITEM",
-                "TRADE", "EQUIP", "REST", "QUEST", "SKILL",
-                "PICKUP", "FLEE", "CUSTOM",
-            }
-            if result["intent"] not in valid_intents:
-                result["intent"] = "CUSTOM"
-            result.setdefault("parser_source", "llm")
-            return result
+        if result and isinstance(result, dict) and "intent" in result:
+            # 验证意图类型合法
+            valid_intents = {
+                "ATTACK", "TALK", "MOVE", "EXPLORE", "USE_ITEM",
+                "TRADE", "EQUIP", "REST", "QUEST", "SKILL",
+                "PICKUP", "FLEE", "CUSTOM",
+            }
+            if result["intent"] not in valid_intents:
+                result["intent"] = "CUSTOM"
+            result.setdefault("parser_source", "llm")
+            return result
 
         return None
 
@@ -234,17 +235,17 @@ class NLUEngine:
         # 尝试提取目标
         target = self._extract_target_from_text(user_input)
 
-        return {
-            "intent": detected_intent,
-            "target": target,
-            "details": None,
-            "parser_source": "keyword_fallback",
-        }
-
-    def _extract_target_from_text(self, text: str) -> Optional[str]:
-        """
-        从文本中提取可能的目标对象。
-        尝试匹配当前场景中的 NPC、物品、地点名称。
+        return {
+            "intent": detected_intent,
+            "target": target,
+            "details": None,
+            "parser_source": "keyword_fallback",
+        }
+
+    def _extract_target_from_text(self, text: str) -> Optional[str]:
+        """
+        从文本中提取可能的目标对象。
+        尝试匹配当前场景中的 NPC、物品、地点名称。
         """
         # 检查 NPC 名称
         for npc_name in self.game_state.world.npcs:
@@ -267,39 +268,127 @@ class NLUEngine:
         for item_name in self.game_state.world.item_registry:
             if item_name in text:
                 return item_name
-
-        return None
-
-    def _apply_intent_postprocessing(self, result: dict, user_input: str) -> dict:
-        """Apply narrow intent corrections for high-confidence mixed phrases."""
-        normalized = dict(result)
-        intent = str(normalized.get("intent", "")).upper()
-        if intent == "MOVE" and self._looks_like_trade_request(user_input, normalized.get("target")):
-            normalized["intent"] = "TRADE"
-            normalized["intent_correction"] = "move_to_trade_for_shop_request"
-        return normalized
-
-    def _looks_like_trade_request(self, user_input: str, target: Optional[str]) -> bool:
-        trade_pattern = r"买|卖|交易|购买|出售|看看有什么卖的|买点"
-        if not re.search(trade_pattern, user_input):
-            return False
-
-        target_text = str(target or "")
-        if target_text:
-            npc = self.game_state.world.npcs.get(target_text)
-            if npc and npc.can_trade:
-                return True
-
-            location = self.game_state.world.locations.get(target_text)
-            if location and location.shop_available:
-                return True
-
-        shop_hint_pattern = r"商店|杂货铺|旅店|铁匠铺"
-        return bool(re.search(shop_hint_pattern, user_input))
-
-    def _build_context(self) -> str:
-        """构建当前场景的简要上下文描述"""
-        gs = self.game_state
+
+        return None
+
+    def _apply_intent_postprocessing(self, result: dict, user_input: str) -> dict:
+        """Apply narrow intent corrections for high-confidence mixed phrases."""
+        normalized = dict(result)
+        intent = str(normalized.get("intent", "")).upper()
+        if intent == "MOVE" and self._looks_like_trade_request(user_input, normalized.get("target")):
+            inferred_trade_target = self._infer_trade_target(user_input, normalized.get("target"))
+            target_text = str(normalized.get("target") or "")
+            target_location = self.game_state.world.locations.get(target_text)
+            # 目标是商店地点且玩家尚未到达时，优先保持 MOVE，避免生成“未到店先扣钱”的错误交易。
+            if (
+                target_location is not None
+                and target_location.shop_available
+                and target_text != self.game_state.player.location
+            ):
+                normalized["intent_correction"] = "preserve_move_for_shop_travel"
+            elif inferred_trade_target is not None:
+                normalized["intent"] = "TRADE"
+                normalized["target"] = inferred_trade_target
+                normalized["intent_correction"] = "move_to_trade_with_structured_target"
+        if intent == "TRADE" and not isinstance(normalized.get("target"), dict):
+            target_text = str(normalized.get("target") or "")
+            target_location = self.game_state.world.locations.get(target_text)
+            if (
+                target_location is not None
+                and target_location.shop_available
+                and target_text != self.game_state.player.location
+            ):
+                normalized["intent"] = "MOVE"
+                normalized["intent_correction"] = "trade_to_move_for_shop_travel"
+                return normalized
+            inferred_trade_target = self._infer_trade_target(user_input, normalized.get("target"))
+            if inferred_trade_target is not None:
+                normalized["target"] = inferred_trade_target
+                normalized["intent_correction"] = "trade_target_inferred_from_text"
+        if intent in {"ATTACK", "COMBAT"}:
+            target = normalized.get("target")
+            if not isinstance(target, str) or not target.strip() or target in {"怪物", "敌人", "它", "那个怪物"}:
+                inferred_target = self._infer_attack_target()
+                if inferred_target:
+                    normalized["target"] = inferred_target
+                    normalized["intent_correction"] = "attack_target_inferred_from_scene"
+        return normalized
+
+    def _looks_like_trade_request(self, user_input: str, target: Optional[str]) -> bool:
+        trade_pattern = r"买|卖|交易|购买|出售|看看有什么卖的|买点"
+        if not re.search(trade_pattern, user_input):
+            return False
+
+        target_text = str(target or "")
+        if target_text:
+            npc = self.game_state.world.npcs.get(target_text)
+            if npc and npc.can_trade:
+                return True
+
+            location = self.game_state.world.locations.get(target_text)
+            if location and location.shop_available:
+                return True
+
+        shop_hint_pattern = r"商店|杂货铺|旅店|铁匠铺"
+        return bool(re.search(shop_hint_pattern, user_input))
+
+    def _infer_attack_target(self) -> Optional[str]:
+        """Infer a concrete ATTACK target from deterministic scene actions first."""
+        try:
+            scene_actions = build_scene_actions(self.game_state, self.game_state.player.location)
+        except Exception:
+            scene_actions = []
+        for action in scene_actions:
+            if str(action.get("action_type", "")).upper() != "ATTACK":
+                continue
+            target = action.get("target")
+            if isinstance(target, str) and target.strip():
+                return target
+
+        current_loc = self.game_state.world.locations.get(self.game_state.player.location)
+        if current_loc and current_loc.enemies:
+            return str(current_loc.enemies[0])
+        return None
+
+    def _infer_trade_target(self, user_input: str, target: object) -> Optional[dict]:
+        """Infer structured trade target for rule-based TRADE handling."""
+        text_blob = f"{user_input} {target if isinstance(target, str) else ''}"
+
+        merchant_name: Optional[str] = None
+        for npc in self.game_state.world.npcs.values():
+            if not npc.can_trade or npc.location != self.game_state.player.location:
+                continue
+            if npc.name in text_blob or (npc.occupation and npc.occupation in text_blob):
+                merchant_name = npc.name
+                break
+
+        if merchant_name is None:
+            for npc in self.game_state.world.npcs.values():
+                if npc.can_trade and npc.location == self.game_state.player.location:
+                    merchant_name = npc.name
+                    break
+        if merchant_name is None:
+            return None
+
+        merchant = self.game_state.world.npcs.get(merchant_name)
+        if merchant is None:
+            return None
+
+        item_name: Optional[str] = None
+        for candidate in merchant.shop_inventory:
+            if candidate in text_blob:
+                item_name = candidate
+                break
+        if item_name is None and isinstance(target, str) and target in merchant.shop_inventory:
+            item_name = target
+        if item_name is None:
+            return None
+
+        return {"merchant": merchant_name, "item": item_name, "confirm": False}
+
+    def _build_context(self) -> str:
+        """构建当前场景的简要上下文描述"""
+        gs = self.game_state
         return (
             f"场景: {gs.world.current_scene}\n"
             f"时间: 第{gs.world.day_count}天 {gs.world.time_of_day}\n"

state_manager.py

@@ -23,7 +23,7 @@ import re
 from typing import Any, Optional
 from pydantic import BaseModel, Field
 
-from demo_rules import OVERNIGHT_REST_LOCATIONS, action_time_cost_minutes
+from demo_rules import OVERNIGHT_REST_LOCATIONS, action_time_cost_minutes, build_scene_actions
 from utils import clamp
 
 logger = logging.getLogger("StoryWeaver")
@@ -250,6 +250,8 @@ class PlayerState(BaseModel):
     max_mp: int = 50                              # 最大魔力值
     attack: int = 10                              # 攻击力
     defense: int = 5                              # 防御力
+    attack_power: int = 10                        # 实战攻击力（基础攻击+装备加成）
+    defense_power: int = 5                        # 实战防御力（基础防御+装备加成）
     stamina: int = 100                            # 体力值
     max_stamina: int = 100                        # 最大体力值
     speed: int = 8                                # 速度（影响行动顺序）
@@ -306,11 +308,11 @@ class WorldState(BaseModel):
     current_scene: str = "村庄广场"                 # 当前场景名称
     time_of_day: str = "清晨"                      # 清晨 / 上午 / 正午 / 下午 / 黄昏 / 夜晚 / 深夜
     day_count: int = 1                            # 当前天数
-    weather: str = "晴朗"                          # 晴朗 / 多云 / 小雨 / 暴风雨 / 大雪 / 浓雾
-    light_level: str = "明亮"                      # 明亮 / 柔和 / 昏暗 / 幽暗 / 漆黑
-    time_progress_units: int = 0                 # 当前时段内累积的动作耗时点数
-    last_weather_change_minutes: int = -999999   # 上次天气变化时的累计分钟数
-    season: str = "春"                             # 春 / 夏 / 秋 / 冬
+    weather: str = "晴朗"                          # 晴朗 / 多云 / 小雨 / 暴风雨 / 大雪 / 浓雾
+    light_level: str = "明亮"                      # 明亮 / 柔和 / 昏暗 / 幽暗 / 漆黑
+    time_progress_units: int = 0                 # 当前时段内累积的动作耗时点数
+    last_weather_change_minutes: int = -999999   # 上次天气变化时的累计分钟数
+    season: str = "春"                             # 春 / 夏 / 秋 / 冬
 
     # --- 地图 ---
     locations: dict[str, LocationInfo] = Field(default_factory=dict)
@@ -427,6 +429,11 @@ class GameState:
 
         # 初始化起始世界
         self._init_starting_world()
+        self.refresh_combat_stats()
+        # 純文本地图渲染使用的“当前位置 + 足迹历史”
+        # current_location 必须始终与 self.player.location 保持一致。
+        self.current_location: str = str(self.player.location)
+        self.location_history: list[str] = []
         self.world.time_progress_units = 36
         self.pending_environment_event: EnvironmentEvent | None = None
         self._sync_world_clock()
@@ -705,58 +712,58 @@ class GameState:
 
         # --- 初始任务 ---
         self.world.quests = {
-            "main_quest_01": QuestState(
-                quest_id="main_quest_01",
-                title="森林中的阴影",
-                description="村长老伯告诉你，最近森林中频繁出现怪物袭击事件。他请求你前往调查。",
-                quest_type="main",
+            "main_quest_01": QuestState(
+                quest_id="main_quest_01",
+                title="森林中的阴影",
+                description="村长老伯告诉你，最近森林中频繁出现怪物袭击事件。他请求你前往调查。",
+                quest_type="main",
                 status="active",
                 giver_npc="村长老伯",
-                objectives={
-                    "与村长对话了解情况": False,
-                    "前往黑暗森林入口调查": False,
-                    "击败森林中的怪物": False,
-                    "调查怪物活动的原因": False,
-                    "与村长老伯对话汇报发现": False,
-                },
+                objectives={
+                    "与村长对话了解情况": False,
+                    "前往黑暗森林入口调查": False,
+                    "击败森林中的怪物": False,
+                    "调查怪物活动的原因": False,
+                    "与村长老伯对话汇报发现": False,
+                },
                 rewards=QuestRewards(
                     gold=100,
                     experience=50,
                     items=["森林之钥"],
                     reputation_changes={"村庄": 20},
-                    karma_change=5,
-                ),
-            ),
-            "main_quest_02": QuestState(
-                quest_id="main_quest_02",
-                title="森林深处的咆哮",
-                description="村长老伯确认森林巨魔已经苏醒，并命你持森林之钥深入黑暗森林，将这头怪物彻底斩杀。",
-                quest_type="main",
-                status="inactive",
-                giver_npc="村长老伯",
-                objectives={
-                    "前往森林深处": False,
-                    "击败森林巨魔": False,
-                },
-                rewards=QuestRewards(
-                    gold=0,
-                    experience=90,
-                    reputation_changes={"村庄": 30},
-                    karma_change=10,
-                ),
-                prerequisites=["main_quest_01"],
-            ),
-            "side_quest_01": QuestState(
-                quest_id="side_quest_01",
-                title="失落的传承",
-                description="神秘旅人似乎在寻找一件古老的遗物。也许帮助他能得到意想不到的回报。",
-                quest_type="side",
-                status="inactive",
-                giver_npc="神秘旅人",
-                objectives={
-                    "与神秘旅人交谈": False,
-                    "找到古老遗物的线索": False,
-                },
+                    karma_change=5,
+                ),
+            ),
+            "main_quest_02": QuestState(
+                quest_id="main_quest_02",
+                title="森林深处的咆哮",
+                description="村长老伯确认森林巨魔已经苏醒，并命你持森林之钥深入黑暗森林，将这头怪物彻底斩杀。",
+                quest_type="main",
+                status="inactive",
+                giver_npc="村长老伯",
+                objectives={
+                    "前往森林深处": False,
+                    "击败森林巨魔": False,
+                },
+                rewards=QuestRewards(
+                    gold=0,
+                    experience=90,
+                    reputation_changes={"村庄": 30},
+                    karma_change=10,
+                ),
+                prerequisites=["main_quest_01"],
+            ),
+            "side_quest_01": QuestState(
+                quest_id="side_quest_01",
+                title="失落的传承",
+                description="神秘旅人似乎在寻找一件古老的遗物。也许帮助他能得到意想不到的回报。",
+                quest_type="side",
+                status="inactive",
+                giver_npc="神秘旅人",
+                objectives={
+                    "与神秘旅人交谈": False,
+                    "找到古老遗物的线索": False,
+                },
                 rewards=QuestRewards(
                     experience=30,
                     items=["神秘卷轴"],
@@ -765,17 +772,17 @@ class GameState:
                 prerequisites=[],
             ),
             # -------- 扩展任务 --------
-            "side_quest_02": QuestState(
-                quest_id="side_quest_02",
-                title="河底的秘密",
-                description="渡口老渔夫说他最近总在河里捞到奇怪的骨头，而且对岸矿洞方向夜里总是有光。他请你去查明真相。",
-                quest_type="side",
-                status="inactive",
-                giver_npc="渡口老渔夫",
-                objectives={
-                    "与渡口老渔夫交谈": False,
-                    "前往废弃矿洞调查": False,
-                    "找到矿洞异常的原因": False,
+            "side_quest_02": QuestState(
+                quest_id="side_quest_02",
+                title="河底的秘密",
+                description="渡口老渔夫说他最近总在河里捞到奇怪的骨头，而且对岸矿洞方向夜里总是有光。他请你去查明真相。",
+                quest_type="side",
+                status="inactive",
+                giver_npc="渡口老渔夫",
+                objectives={
+                    "与渡口老渔夫交谈": False,
+                    "前往废弃矿洞调查": False,
+                    "找到矿洞异常的原因": False,
                 },
                 rewards=QuestRewards(
                     gold=60,
@@ -785,17 +792,17 @@ class GameState:
                 ),
                 prerequisites=[],
             ),
-            "side_quest_03": QuestState(
-                quest_id="side_quest_03",
-                title="守护者的试炼",
-                description="精灵遗迹的守护者提出一个交换条件：通过她设下的试炼，就能获得古老的精灵祝福。",
-                quest_type="side",
-                status="inactive",
-                giver_npc="遗迹守护者",
-                objectives={
-                    "与遗迹守护者交谈": False,
-                    "通过守护者的试炼": False,
-                },
+            "side_quest_03": QuestState(
+                quest_id="side_quest_03",
+                title="守护者的试炼",
+                description="精灵遗迹的守护者提出一个交换条件：通过她设下的试炼，就能获得古老的精灵祝福。",
+                quest_type="side",
+                status="inactive",
+                giver_npc="遗���守护者",
+                objectives={
+                    "与遗迹守护者交谈": False,
+                    "通过守护者的试炼": False,
+                },
                 rewards=QuestRewards(
                     experience=50,
                     unlock_skill="精灵祝福",
@@ -918,6 +925,34 @@ class GameState:
     # 核心方法
     # ============================================================
 
+    def update_location(self, new_location: str) -> None:
+        """
+        更新当前位置并维护足迹历史。
+
+        规则：
+        - 当 new_location 与当前地点不同：把旧地点写入 location_history，然后更新 current_location
+        - 当 new_location 相同：不追加历史
+        - 同步更新 self.player.location 与 self.world.current_scene，确保一致性
+        """
+        target = str(new_location or "").strip()
+        if not target:
+            return
+        if target == self.current_location:
+            return
+
+        old_location = self.current_location
+        if old_location:
+            self.location_history.append(old_location)
+
+        # 让游戏状态和地图状态始终一致
+        self.current_location = target
+        self.player.location = target
+        self.world.current_scene = target
+
+    # ============================================================
+    # 状态变更应用
+    # ============================================================
+
     def apply_changes(self, changes: dict) -> list[str]:
         """
         接收 Qwen 返回的状态变更 JSON，校验并应用到当前状态。
@@ -1049,8 +1084,7 @@ class GameState:
                 ):
                     change_log.append(f"忽略未解锁地点: {new_loc}")
                 else:
-                    self.player.location = new_loc
-                    self.world.current_scene = new_loc
+                    self.update_location(new_loc)
                     change_log.append(f"位置: {old_loc} → {new_loc}")
                     # 发现新地点
                     if new_loc not in self.world.discovered_locations:
@@ -1203,16 +1237,16 @@ class GameState:
                         change_log.append(f"任务【{quest.title}】进展至\"{status_cn}\"")
 
         # --- 世界状态变更 ---
-        if "weather_change" in changes:
-            valid_weathers = {"晴朗", "多云", "小雨", "暴风雨", "大雪", "浓雾"}
-            new_weather = str(changes["weather_change"])
-            if new_weather in valid_weathers:
-                if self.world.weather != new_weather:
-                    self.world.weather = new_weather
-                    self.world.last_weather_change_minutes = self.elapsed_minutes_total
-                    change_log.append(f"天气变为: {self.world.weather}")
-            else:
-                logger.warning(f"无效的 weather_change 值 '{new_weather}'，已忽略。")
+        if "weather_change" in changes:
+            valid_weathers = {"晴朗", "多云", "小雨", "暴风雨", "大雪", "浓雾"}
+            new_weather = str(changes["weather_change"])
+            if new_weather in valid_weathers:
+                if self.world.weather != new_weather:
+                    self.world.weather = new_weather
+                    self.world.last_weather_change_minutes = self.elapsed_minutes_total
+                    change_log.append(f"天气变为: {self.world.weather}")
+            else:
+                logger.warning(f"无效的 weather_change 值 '{new_weather}'，已忽略。")
 
         if "time_change" in changes:
             valid_times = ["清晨", "上午", "正午", "下午", "黄昏", "夜晚", "深夜"]
@@ -1274,6 +1308,9 @@ class GameState:
             self.player.title = str(changes["title_change"])
             change_log.append(f"称号: {old_title} → {self.player.title}")
 
+        # 战斗派生属性需要与装备和基础属性保持同步
+        self.refresh_combat_stats()
+
         if change_log:
             logger.info(f"状态变更: {change_log}")
 
@@ -1341,6 +1378,12 @@ class GameState:
                 bonuses[stat_name] = bonuses.get(stat_name, 0) + int(amount)
         return bonuses
 
+    def refresh_combat_stats(self) -> None:
+        """Refresh deterministic combat stats from base values + equipment bonuses."""
+        bonuses = self.get_equipment_stat_bonuses()
+        self.player.attack_power = max(1, int(self.player.attack) + int(bonuses.get("attack", 0)))
+        self.player.defense_power = max(0, int(self.player.defense) + int(bonuses.get("defense", 0)))
+
     def _status_multiplier(self, value: int) -> float:
         if value >= 90:
             return 1.5
@@ -1412,17 +1455,17 @@ class GameState:
                 effective_stats[stat_name] = clamp(boosted_value, 1, max(cap, boosted_value))
         return effective_stats
 
-    def get_clock_minutes(self) -> int:
-        return int(self.world.time_progress_units) * 10
-
-    def get_minute_of_day(self) -> int:
-        return self.get_clock_minutes() % (24 * 60)
-
-    def get_clock_display(self) -> str:
-        total_minutes = self.get_clock_minutes() % (24 * 60)
-        hours = total_minutes // 60
-        minutes = total_minutes % 60
-        return f"{hours:02d}:{minutes:02d}"
+    def get_clock_minutes(self) -> int:
+        return int(self.world.time_progress_units) * 10
+
+    def get_minute_of_day(self) -> int:
+        return self.get_clock_minutes() % (24 * 60)
+
+    def get_clock_display(self) -> str:
+        total_minutes = self.get_clock_minutes() % (24 * 60)
+        hours = total_minutes // 60
+        minutes = total_minutes % 60
+        return f"{hours:02d}:{minutes:02d}"
 
     def _time_of_day_from_minutes(self, total_minutes: int) -> str:
         minute_of_day = total_minutes % (24 * 60)
@@ -1440,63 +1483,63 @@ class GameState:
             return "夜晚"
         return "深夜"
 
-    def _sync_world_clock(self):
-        self.world.time_of_day = self._time_of_day_from_minutes(self.get_clock_minutes())
-
-    def can_overnight_rest(self) -> bool:
-        current_loc = self.world.locations.get(self.player.location)
-        if current_loc is None or not current_loc.rest_available:
-            return False
-        if self.player.location not in OVERNIGHT_REST_LOCATIONS:
-            return False
-        return self.get_minute_of_day() >= 19 * 60
-
-    def prepare_overnight_rest(self) -> tuple[list[str], dict[str, int]]:
-        """Advance to next morning and return full-recovery deltas for overnight rest."""
-        if not self.can_overnight_rest():
-            return [], {}
-
-        old_clock = self.get_clock_display()
-        old_time_of_day = self.world.time_of_day
-        old_day_count = self.world.day_count
-        old_light = self.world.light_level
-
-        minute_of_day = self.get_minute_of_day()
-        minutes_until_midnight = (24 * 60) - minute_of_day
-        target_elapsed_minutes = self.elapsed_minutes_total + minutes_until_midnight + 6 * 60
-
-        self.elapsed_minutes_total = target_elapsed_minutes
-        self.world.day_count = target_elapsed_minutes // (24 * 60) + 1
-        self.world.time_progress_units = (target_elapsed_minutes % (24 * 60)) // 10
-        self._sync_world_clock()
-        self.world.light_level = self._determine_light_level()
-
-        tick_log: list[str] = []
-        if self.world.day_count != old_day_count:
-            tick_log.append(f"新的一天！第{self.world.day_count}天")
-
-        new_clock = self.get_clock_display()
-        if new_clock != old_clock:
-            tick_log.append(f"时间流逝: {old_clock} → {new_clock}")
-        if self.world.time_of_day != old_time_of_day:
-            tick_log.append(f"时段变化: {old_time_of_day} → {self.world.time_of_day}")
-        if self.world.light_level != old_light:
-            tick_log.append(f"光照变化: {old_light} → {self.world.light_level}")
-
-        hunger_cost = 20 if self.player.location == "村庄旅店" else 25
-        recovery_changes: dict[str, int] = {
-            "hp_change": self.player.max_hp - self.player.hp,
-            "mp_change": self.player.max_mp - self.player.mp,
-            "stamina_change": self.player.max_stamina - self.player.stamina,
-            "morale_change": 100 - self.player.morale,
-            "sanity_change": 100 - self.player.sanity,
-            "hunger_change": -hunger_cost,
-        }
-        return tick_log, {
-            key: value
-            for key, value in recovery_changes.items()
-            if int(value) != 0
-        }
+    def _sync_world_clock(self):
+        self.world.time_of_day = self._time_of_day_from_minutes(self.get_clock_minutes())
+
+    def can_overnight_rest(self) -> bool:
+        current_loc = self.world.locations.get(self.player.location)
+        if current_loc is None or not current_loc.rest_available:
+            return False
+        if self.player.location not in OVERNIGHT_REST_LOCATIONS:
+            return False
+        return self.get_minute_of_day() >= 19 * 60
+
+    def prepare_overnight_rest(self) -> tuple[list[str], dict[str, int]]:
+        """Advance to next morning and return full-recovery deltas for overnight rest."""
+        if not self.can_overnight_rest():
+            return [], {}
+
+        old_clock = self.get_clock_display()
+        old_time_of_day = self.world.time_of_day
+        old_day_count = self.world.day_count
+        old_light = self.world.light_level
+
+        minute_of_day = self.get_minute_of_day()
+        minutes_until_midnight = (24 * 60) - minute_of_day
+        target_elapsed_minutes = self.elapsed_minutes_total + minutes_until_midnight + 6 * 60
+
+        self.elapsed_minutes_total = target_elapsed_minutes
+        self.world.day_count = target_elapsed_minutes // (24 * 60) + 1
+        self.world.time_progress_units = (target_elapsed_minutes % (24 * 60)) // 10
+        self._sync_world_clock()
+        self.world.light_level = self._determine_light_level()
+
+        tick_log: list[str] = []
+        if self.world.day_count != old_day_count:
+            tick_log.append(f"新的一天！第{self.world.day_count}天")
+
+        new_clock = self.get_clock_display()
+        if new_clock != old_clock:
+            tick_log.append(f"时间流逝: {old_clock} → {new_clock}")
+        if self.world.time_of_day != old_time_of_day:
+            tick_log.append(f"时段变化: {old_time_of_day} → {self.world.time_of_day}")
+        if self.world.light_level != old_light:
+            tick_log.append(f"光照变化: {old_light} → {self.world.light_level}")
+
+        hunger_cost = 20 if self.player.location == "村庄旅店" else 25
+        recovery_changes: dict[str, int] = {
+            "hp_change": self.player.max_hp - self.player.hp,
+            "mp_change": self.player.max_mp - self.player.mp,
+            "stamina_change": self.player.max_stamina - self.player.stamina,
+            "morale_change": 100 - self.player.morale,
+            "sanity_change": 100 - self.player.sanity,
+            "hunger_change": -hunger_cost,
+        }
+        return tick_log, {
+            key: value
+            for key, value in recovery_changes.items()
+            if int(value) != 0
+        }
 
     def to_prompt(self) -> str:
         """
@@ -1536,8 +1579,10 @@ class GameState:
         player_desc = (
             f"【玩家】{self.player.name}（{self.player.title}）\n"
             f"  等级: {self.player.level} | 经验: {self.player.experience}/{self.player.exp_to_next_level}\n"
-            f"  HP: {self.player.hp}/{self.player.max_hp} | MP: {self.player.mp}/{self.player.max_mp}\n"
-            f"  攻击: {self.player.attack} | 防御: {self.player.defense} | 速度: {self.player.speed} | 幸运: {self.player.luck} | 感知: {self.player.perception}\n"
+            f"  HP: {self.player.hp}/{self.player.max_hp}\n"
+            f"  MP: {self.player.mp}/{self.player.max_mp}\n"
+            f"  攻击: {self.player.attack} | 防御: {self.player.defense} | 实战攻击: {self.player.attack_power} | 实战防御: {self.player.defense_power}\n"
+            f"  速度: {self.player.speed} | 幸运: {self.player.luck} | 感知: {self.player.perception}\n"
             f"  金币: {self.player.gold} | 善恶值: {self.player.karma}\n"
             f"  士气: {self.player.morale} | 理智: {self.player.sanity} | 饱食度: {self.player.hunger}\n"
             f"  装备: {equip_str}\n"
@@ -1782,9 +1827,11 @@ class GameState:
             (is_valid, rejection_reason): 合法返回 (True, ""), 否则返回 (False, "拒绝原因")
         """
         action = intent.get("intent", "")
+        raw_target = intent.get("target")
         target = intent.get("target", "") or ""
         details = intent.get("details", "") or ""
         raw_input = intent.get("raw_input", "") or ""
+        action_upper = str(action or "").upper()
 
         inventory = list(self.player.inventory)
         equipped_items = [v for v in self.player.equipment.values() if v]
@@ -1803,20 +1850,88 @@ class GameState:
 
         normalized_target = normalize_item_phrase(target)
 
+        def _resolve_dialogue_npc() -> NPCState | None:
+            """Resolve TALK target from explicit target or alias mentions in free text."""
+            text_blob = f"{target} {details} {raw_input}".strip()
+            if not text_blob:
+                return None
+
+            # 1) Exact NPC name match first.
+            explicit_target = str(target or "").strip()
+            if explicit_target and explicit_target in self.world.npcs:
+                npc = self.world.npcs.get(explicit_target)
+                if npc and npc.is_alive:
+                    return npc
+
+            # 2) Name / occupation fuzzy match from free text (e.g. "和村长聊天").
+            alive_npcs = [npc for npc in self.world.npcs.values() if npc.is_alive]
+            ranked_candidates: list[tuple[int, NPCState]] = []
+            for npc in alive_npcs:
+                score = 0
+                if npc.name and npc.name in text_blob:
+                    score += 3
+                if explicit_target and (
+                    (npc.name and explicit_target in npc.name)
+                    or (npc.name and npc.name in explicit_target)
+                ):
+                    score += 2
+                if npc.occupation and npc.occupation in text_blob:
+                    score += 2
+                if explicit_target and npc.occupation and (
+                    explicit_target in npc.occupation or npc.occupation in explicit_target
+                ):
+                    score += 1
+                if score > 0:
+                    ranked_candidates.append((score, npc))
+
+            if ranked_candidates:
+                ranked_candidates.sort(key=lambda item: item[0], reverse=True)
+                return ranked_candidates[0][1]
+
+            return None
+
         # --- 检测 1: USE_ITEM / EQUIP: target 必须在背包或装备中 ---
-        if action in ("USE_ITEM", "EQUIP") and target:
+        if action_upper in ("USE_ITEM", "EQUIP") and target:
             if target not in all_owned:
                 return False, f"你的背包中没有「{target}」，无法使用或装备。"
-            if action == "EQUIP" and target not in inventory:
+            if action_upper == "EQUIP" and target not in inventory:
                 if target in equipped_items:
                     return False, f"「{target}」已经装备在身上了。"
                 return False, f"你的背包中没有「{target}」，无法装备。"
 
         # 体力耗尽时禁止移动和战斗
-        if action in ("MOVE", "ATTACK", "COMBAT") and self.player.stamina <= 0:
+        if action_upper in ("MOVE", "ATTACK", "COMBAT") and self.player.stamina <= 0:
             return False, "你精疲力竭，体力耗尽，无法行动。需要先在旅店或营地休息恢复体力。"
 
-        if action == "MOVE" and target:
+        if action_upper == "TRADE":
+            if not isinstance(raw_target, dict):
+                return False, "交易指令缺少商品信息，请从商店列表中选择要购买的物品。"
+            merchant_name = str(raw_target.get("merchant") or "")
+            item_name = str(raw_target.get("item") or raw_target.get("item_name") or "")
+            if not merchant_name or not item_name:
+                return False, "交易信息不完整，请重新从商店列表选择商品。"
+
+        if action_upper in ("ATTACK", "COMBAT"):
+            scene_actions = build_scene_actions(self, self.player.location)
+            attack_targets = [
+                str(option.get("target"))
+                for option in scene_actions
+                if str(option.get("action_type", "")).upper() == "ATTACK"
+                and isinstance(option.get("target"), str)
+                and str(option.get("target")).strip()
+            ]
+            if target:
+                if target not in attack_targets:
+                    if attack_targets:
+                        return (
+                            False,
+                            f"当前无法攻击「{target}」。你现在可攻击的目标只有：{'、'.join(attack_targets)}。",
+                        )
+                    return False, "当前场景没有可攻击目标，先观察环境或移动到有敌人的地点。"
+            elif not attack_targets:
+                return False, "当前场景没有可攻击目标，先观察环境或移动到有敌人的地点。"
+
+        if action_upper == "MOVE" and target:
             current_loc = self.world.locations.get(self.player.location)
             target_loc = self.world.locations.get(str(target))
             if current_loc is None or target_loc is None:
@@ -1828,27 +1943,46 @@ class GameState:
                     return False, f"「{target}」尚未解锁，需要「{target_loc.required_item}」。"
                 return False, f"「{target}」当前无法进入。"
 
-        if action == "VIEW_MAP":
+        if action_upper == "VIEW_MAP":
             if not any("地图" in item for item in all_owned):
                 return False, "你还没有获得可查看的地图。"
 
+        # --- 检测 2: TALK: 对话对象必须在当前地点 ---
+        if action_upper == "TALK":
+            dialogue_npc = _resolve_dialogue_npc()
+            if dialogue_npc is not None:
+                if dialogue_npc.location != self.player.location:
+                    return (
+                        False,
+                        f"「{dialogue_npc.name}」目前在「{dialogue_npc.location}」，你现在在「{self.player.location}」。"
+                        f"无法隔空对话，请先前往对方所在地点。"
+                    )
+            else:
+                local_alive_npcs = [
+                    npc.name
+                    for npc in self.world.npcs.values()
+                    if npc.is_alive and npc.location == self.player.location
+                ]
+                if not local_alive_npcs:
+                    return False, "这里没有可对话的角色，无法进行聊天。"
+
         # --- 检测 2: SKILL: 必须已习得 ---
-        if action == "SKILL" and target:
+        if action_upper == "SKILL" and target:
             if target not in self.player.skills:
                 return False, f"你尚未习得技能「{target}」。"
 
-        wants_overnight_rest = str(action).upper() == "OVERNIGHT_REST" or (
-            str(action).upper() == "REST"
-            and any(keyword in f"{details} {raw_input}" for keyword in ("过夜", "睡一晚", "住一晚", "睡到天亮"))
-        )
-
-        # --- 检测 3: REST/OVERNIGHT_REST: 当前位置必须允许休息 ---
-        if action in ("REST", "OVERNIGHT_REST"):
-            current_loc = self.world.locations.get(self.player.location)
-            if current_loc is None or not current_loc.rest_available:
-                return False, "这里不适合休息，试着前往旅店或营地。"
-            if wants_overnight_rest and not self.can_overnight_rest():
-                return False, "现在还不能在这里过夜。晚上七点后，且仅限旅店或溪边营地。"
+        wants_overnight_rest = action_upper == "OVERNIGHT_REST" or (
+            action_upper == "REST"
+            and any(keyword in f"{details} {raw_input}" for keyword in ("过夜", "睡一晚", "住一晚", "睡到天亮"))
+        )
+
+        # --- 检测 3: REST/OVERNIGHT_REST: 当前位置必须允许休息 ---
+        if action_upper in ("REST", "OVERNIGHT_REST"):
+            current_loc = self.world.locations.get(self.player.location)
+            if current_loc is None or not current_loc.rest_available:
+                return False, "这里不适合休息，试着前往旅店或营地。"
+            if wants_overnight_rest and not self.can_overnight_rest():
+                return False, "现在还不能在这里过夜。晚上七点后，且仅限旅店或溪边营地。"
 
         # --- 检测 4: 扫描 raw_input 中是否在使用上下文中引用了未拥有的已知物品 ---
         known_items: set[str] = set(self.world.item_registry.keys())
@@ -2096,13 +2230,13 @@ class GameState:
             inject_prompt=new_light in {"昏暗", "幽暗", "漆黑"},
         )
 
-    def _maybe_shift_weather(self, tick_log: list[str]):
-        """Occasionally shift weather to keep the environment dynamic."""
-        if self.elapsed_minutes_total - int(self.world.last_weather_change_minutes) < 180:
-            return
-        chance = 0.18 if self.world.time_of_day in {"清晨", "黄昏"} else 0.08
-        if random.random() >= chance:
-            return
+    def _maybe_shift_weather(self, tick_log: list[str]):
+        """Occasionally shift weather to keep the environment dynamic."""
+        if self.elapsed_minutes_total - int(self.world.last_weather_change_minutes) < 180:
+            return
+        chance = 0.18 if self.world.time_of_day in {"清晨", "黄昏"} else 0.08
+        if random.random() >= chance:
+            return
 
         weather_transitions = {
             "晴朗": ["多云", "小雨"],
@@ -2149,13 +2283,14 @@ class GameState:
         if loc is None or not self.environment_event_pool:
             return
 
-        chance = 0.08
+        # 提高基础触发率，让环境事件更常进入叙事与决策反馈
+        chance = 0.15
         if loc.danger_level >= 3:
-            chance += 0.08
+            chance += 0.1
         if self.world.light_level in {"幽暗", "漆黑"}:
-            chance += 0.06
+            chance += 0.08
         if self.world.weather in {"暴风雨", "浓雾"}:
-            chance += 0.04
+            chance += 0.06
         if random.random() >= chance:
             return
 

utils.py

@@ -10,17 +10,17 @@ utils.py - StoryWeaver 工具函数模块
 import os
 import re
 import json
-import time
-import logging
-from typing import Any, Optional
-from dotenv import load_dotenv
-
-try:
-    from openai import OpenAI
-    _OPENAI_IMPORT_ERROR: Optional[Exception] = None
-except ImportError as exc:  # pragma: no cover - depends on local env
-    OpenAI = None  # type: ignore[assignment]
-    _OPENAI_IMPORT_ERROR = exc
+import time
+import logging
+from typing import Any, Optional
+from dotenv import load_dotenv
+
+try:
+    from openai import OpenAI
+    _OPENAI_IMPORT_ERROR: Optional[Exception] = None
+except ImportError as exc:  # pragma: no cover - depends on local env
+    OpenAI = None  # type: ignore[assignment]
+    _OPENAI_IMPORT_ERROR = exc
 
 # ============================================================
 # 日志配置
@@ -49,22 +49,22 @@ if not QWEN_API_KEY or QWEN_API_KEY == "sk-xxxxxx":
 
 # 使用 OpenAI 兼容格式连接 Qwen API
 # base_url 指向通义千问的 OpenAI 兼容端点
-_client: Optional[Any] = None
-
-
-def get_client() -> Any:
+_client: Optional[Any] = None
+
+
+def get_client() -> Any:
     """
     获取全局 OpenAI 客户端（懒加载单例）。
-    使用兼容格式调用 Qwen API。
-    """
-    global _client
-    if OpenAI is None:
-        raise RuntimeError(
-            "未安装 openai 依赖，无法初始化 Qwen 客户端。"
-            "请先执行 `pip install -r requirements.txt`。"
-        ) from _OPENAI_IMPORT_ERROR
-    if _client is None:
-        _client = OpenAI(
+    使用兼容格式调用 Qwen API。
+    """
+    global _client
+    if OpenAI is None:
+        raise RuntimeError(
+            "未安装 openai 依赖，无法初始化 Qwen 客户端。"
+            "请先执行 `pip install -r requirements.txt`。"
+        ) from _OPENAI_IMPORT_ERROR
+    if _client is None:
+        _client = OpenAI(
             api_key=QWEN_API_KEY,
             base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
         )
@@ -74,8 +74,8 @@ def get_client() -> Any:
 # ============================================================
 # 默认模型配置
 # ============================================================
-# 使用 qwen-turbo 以获得最快的响应速度
-DEFAULT_MODEL: str = "qwen-turbo"
+# 使用 qwen2.5-14b-instruct 以获得最快的响应速度
+DEFAULT_MODEL: str = "qwen2.5-14b-instruct"
 
 
 # ============================================================