feat: add environment UI and tighten trade, state, and action-time rules

app.py

@@ -66,6 +66,7 @@ def _build_state_snapshot(gs: GameState) -> dict:
     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(
@@ -85,6 +86,8 @@ def _build_state_snapshot(gs: GameState) -> dict:
         "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,
@@ -816,6 +819,8 @@ def _format_status_panel(gs: GameState) -> str:
     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)
+    scene_summary = gs.get_scene_summary().replace("\n", "<br>")
 
     # 属性进度条
     hp_bar = _progress_bar(p.hp, p.max_hp, "HP")
@@ -843,6 +848,13 @@ def _format_status_panel(gs: GameState) -> str:
         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:
@@ -855,8 +867,65 @@ def _format_status_panel(gs: GameState) -> str:
     # 背包
     if p.inventory:
         inventory_text = "<br>".join(p.inventory)
-    else:
-        inventory_text = "空"
+    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"]
@@ -949,30 +1018,47 @@ def _format_status_panel(gs: GameState) -> str:
 </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>
-<span style="font-size:0.85em;">
-{quest_text}
-</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;">
+{env_badges}
+{latest_event_html}
+<span style="color:#475569;">最���环境事件: {recent_event_lines}</span>
+</div>
+</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:10px;background:#fff7ed;border:1px solid #fed7aa;">
+{scene_summary}
+</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>
 <span style="font-size:0.85em;">
 位置: {w.current_scene}<br>
-时间: 第{w.day_count}天 {w.time_of_day}<br>
-天气: {w.weather}<br>
-季节: {w.season}<br>
-回合: {gs.turn}
-</span>
-</div>
+时间: 第{w.day_count}天 {w.time_of_day}<br>
+天气: {w.weather}<br>
+光照: {w.light_level}<br>
+季节: {w.season}<br>
+回合: {gs.turn}
+</span>
+</div>
 
 </div>
 </div>"""

state_manager.py

@@ -16,11 +16,12 @@ state_manager.py - StoryWeaver 状态管理器
 
 from __future__ import annotations
 
-import copy
-import logging
-import re
-from typing import Any, Optional
-from pydantic import BaseModel, Field
+import copy
+import logging
+import random
+import re
+from typing import Any, Optional
+from pydantic import BaseModel, Field
 
 from utils import clamp
 
@@ -288,7 +289,7 @@ class PlayerState(BaseModel):
 # ============================================================
 
 
-class WorldState(BaseModel):
+class WorldState(BaseModel):
     """
     世界状态容器
 
@@ -299,11 +300,13 @@ class WorldState(BaseModel):
     - rumors / active_threats 丰富 NPC 对话内容
     - faction_relations 支持阵营间动态关系
     """
-    current_scene: str = "村庄广场"                 # 当前场景名称
-    time_of_day: str = "清晨"                      # 清晨 / 上午 / 正午 / 下午 / 黄昏 / 夜晚 / 深夜
-    day_count: int = 1                            # 当前天数
-    weather: str = "晴朗"                          # 晴朗 / 多云 / 小雨 / 暴风雨 / 大雪 / 浓雾
-    season: str = "春"                             # 春 / 夏 / 秋 / 冬
+    current_scene: str = "村庄广场"                 # 当前场景名称
+    time_of_day: str = "清晨"                      # 清晨 / 上午 / 正午 / 下午 / 黄昏 / 夜晚 / 深夜
+    day_count: int = 1                            # 当前天数
+    weather: str = "晴朗"                          # 晴朗 / 多云 / 小雨 / 暴风雨 / 大雪 / 浓雾
+    light_level: str = "明亮"                      # 明亮 / 柔和 / 昏暗 / 幽暗 / 漆黑
+    time_progress_units: int = 0                 # 当前时段内累积的动作耗时点数
+    season: str = "春"                             # 春 / 夏 / 秋 / 冬
 
     # --- 地图 ---
     locations: dict[str, LocationInfo] = Field(default_factory=dict)
@@ -319,11 +322,12 @@ class WorldState(BaseModel):
     item_registry: dict[str, ItemInfo] = Field(default_factory=dict)
 
     # --- 全局标记 ---
-    global_flags: dict[str, bool] = Field(default_factory=dict)
-    world_events: list[str] = Field(default_factory=list)
-                                                  # 已发生的全局事件
-    active_threats: list[str] = Field(default_factory=list)
-                                                  # 当前全局威胁
+    global_flags: dict[str, bool] = Field(default_factory=dict)
+    world_events: list[str] = Field(default_factory=list)
+                                                  # 已发生的全局事件
+    recent_environment_events: list["EnvironmentEvent"] = Field(default_factory=list)
+    active_threats: list[str] = Field(default_factory=list)
+                                                  # 当前全局威胁
     rumors: list[str] = Field(default_factory=list)
                                                   # 流传的传闻
     faction_relations: dict[str, dict[str, str]] = Field(default_factory=dict)
@@ -335,7 +339,7 @@ class WorldState(BaseModel):
 # ============================================================
 
 
-class GameEvent(BaseModel):
+class GameEvent(BaseModel):
     """
     事件日志模型（一致性维护的关键）
 
@@ -357,9 +361,27 @@ class GameEvent(BaseModel):
     state_changes: dict = Field(default_factory=dict)
                                                   # 状态变更快照
     player_action: str = ""                       # 触发该事件的玩家操作
-    consequence_tags: list[str] = Field(default_factory=list)
-                                                  # 后果标签
-    is_reversible: bool = True                    # 是否可逆
+    consequence_tags: list[str] = Field(default_factory=list)
+                                                  # 后果标签
+    is_reversible: bool = True                    # 是否可逆
+
+
+class EnvironmentEvent(BaseModel):
+    """Structured environment event used by UI, logs, and prompt injection."""
+    event_id: str
+    category: str = "environment"                 # weather / light / environment
+    title: str = ""
+    description: str = ""
+    location: str = ""
+    time_of_day: str = ""
+    weather: str = ""
+    light_level: str = ""
+    severity: str = "low"                         # low / medium / high
+    state_changes: dict[str, Any] = Field(default_factory=dict)
+    prompt_hint: str = ""
+
+
+WorldState.model_rebuild()
 
 
 # ============================================================
@@ -383,11 +405,11 @@ class GameState:
     - check_consistency() 在生成前检测可能的矛盾
     """
 
-    def __init__(self, player_name: str = "旅人"):
-        """初始化游戏状态，创建默认的起始世界"""
-        self.player = PlayerState(name=player_name)
-        self.world = WorldState()
-        self.event_log: list[GameEvent] = []
+    def __init__(self, player_name: str = "旅人"):
+        """初始化游戏状态，创建默认的起��世界"""
+        self.player = PlayerState(name=player_name)
+        self.world = WorldState()
+        self.event_log: list[GameEvent] = []
         self.turn: int = 0
         self.game_mode: str = "exploration"       # exploration / combat / dialogue / cutscene / game_over
         self.difficulty: str = "normal"            # easy / normal / hard
@@ -395,9 +417,11 @@ class GameState:
         self.ending_flags: dict[str, bool] = {}   # 结局条件追踪
         self.combat_log: list[str] = []           # 最近战斗记录
         self.achievement_list: list[str] = []     # 已解锁成就
-
-        # 初始化起始世界
-        self._init_starting_world()
+
+        # 初始化起始世界
+        self._init_starting_world()
+        self.pending_environment_event: EnvironmentEvent | None = None
+        self.world.light_level = self._determine_light_level()
 
     def _init_starting_world(self):
         """
@@ -590,7 +614,7 @@ class GameState:
                 race="矮人",
                 occupation="铁匠",
                 can_trade=True,
-                shop_inventory=["铁剑", "皮甲", "木盾"],
+                shop_inventory=["小刀", "短剑", "铁剑", "皮甲", "木盾"],
                 relationship_level=0,
                 schedule={"清晨": "村庄铁匠铺", "正午": "村庄铁匠铺", "夜晚": "村庄旅店"},
                 backstory="曾经是王都的御用铁匠，因一场变故隐居此地。对远方的怪物有独到的了解。",
@@ -756,7 +780,9 @@ class GameState:
 
         # --- 初始物品注册表 ---
         self.world.item_registry = {
-            "铁剑": ItemInfo(name="铁剑", item_type="weapon", description="一把标准的铁制长剑，刀锋锐利。", rarity="common", stat_bonus={"attack": 5}, value=30),
+            "小刀": ItemInfo(name="小刀", item_type="weapon", description="一把朴素但实用的小刀，便于近身防身。", rarity="common", stat_bonus={"attack": 2}, value=5),
+            "短剑": ItemInfo(name="短剑", item_type="weapon", description="一把适合新手携带的短剑，轻便易用。", rarity="common", stat_bonus={"attack": 3}, value=10),
+            "铁剑": ItemInfo(name="铁剑", item_type="weapon", description="一把标准的铁制长剑，刀锋锐利。", rarity="common", stat_bonus={"attack": 5}, value=30),
             "皮甲": ItemInfo(name="皮甲", item_type="armor", description="硬化皮革制成的轻甲，兼顾防护与灵活性。", rarity="common", stat_bonus={"defense": 3}, value=25),
             "木盾": ItemInfo(name="木盾", item_type="armor", description="坚硬橡木制成的盾牌，可以抵挡基础攻击。", rarity="common", stat_bonus={"defense": 2}, value=15),
             "面包": ItemInfo(name="面包", item_type="consumable", description="新鲜烤制的面包，香气扑鼻。", usable=True, use_effect="恢复 10 饱食度", value=5),
@@ -791,21 +817,71 @@ class GameState:
             "有人在精灵遗迹附近见到过一个穿绿袍的身影，不知是人是鬼。",
         ]
 
-        # --- 随机事件候选池 ---
-        self.random_event_pool: list[str] = [
-            "一个受伤的旅行商人跌跌撞撞地出现在你面前，他的货物散落一地。",
-            "天空忽然暗了下来，远处传来隐约的雷声，一场暴雨似乎即将来临。",
-            "你注意到路边有一个被藤蔓遮住的旧箱子，看起来已经放了很久。",
-            "一只受伤的猎鹰坠落在你脚边，它的腿上绑着一小卷羊皮纸。",
-            "远处传来激烈的打斗声，似乎有人遭到了伏击。",
-            "一个衣衫褴褛的流浪汉向你走来，自称知道附近藏宝的秘密。",
-            "你经过的路上发现了一串新鲜的、不属于任何已知生物的巨大脚印。",
-            "一阵古怪的风带来了焦糊的味道，顺着风向看去，远处有一缕黑烟升起。",
-        ]
-        self.pending_random_event: str | None = None  # 本回合触发的随机事件
-
-        # --- 玩家初始装备 ---
-        self.player.inventory = ["面包", "面包", "小型治疗药水"]
+        # --- 显式环境事件模板 ---
+        self.environment_event_pool: list[dict[str, Any]] = [
+            {
+                "event_id": "lanterns_dim",
+                "category": "light",
+                "title": "灯火忽暗",
+                "description": "屋内的灯火突然暗了一截，墙角的影子被拉得细长。",
+                "location_types": ["town", "shop"],
+                "time_slots": ["黄昏", "夜晚", "深夜"],
+                "severity": "medium",
+                "state_changes": {"sanity_change": -2},
+                "prompt_hint": "环境光线明显变暗，叙事里要体现角色对阴影和氛围变化的反应。",
+            },
+            {
+                "event_id": "cold_gust",
+                "category": "environment",
+                "title": "冷风穿林",
+                "description": "一阵带着湿意的冷风从林间掠过，让人本能地绷紧肩背。",
+                "location_types": ["wilderness", "dungeon"],
+                "time_slots": ["下午", "黄昏", "夜晚", "深夜"],
+                "severity": "low",
+                "state_changes": {"morale_change": -3},
+                "prompt_hint": "风声和体感温度都发生了变化，适合让玩家察觉环境压力正在上升。",
+            },
+            {
+                "event_id": "forest_rustle",
+                "category": "environment",
+                "title": "林影骚动",
+                "description": "黑暗树影间传来急促的窸窣声，仿佛刚有什么东西贴着边缘掠过。",
+                "location_types": ["wilderness", "dungeon"],
+                "time_slots": ["黄昏", "夜晚", "深夜"],
+                "min_danger": 3,
+                "severity": "medium",
+                "state_changes": {"sanity_change": -3},
+                "prompt_hint": "这是偏悬疑的环境扰动，至少一个后续选项应允许玩家追查或回避。",
+            },
+            {
+                "event_id": "fireplace_relief",
+                "category": "environment",
+                "title": "火光回暖",
+                "description": "炉火和热气驱散了紧绷感，让呼吸也慢慢平稳下来。",
+                "location_types": ["shop", "town"],
+                "requires_rest_available": True,
+                "time_slots": ["黄昏", "夜晚", "深夜"],
+                "severity": "low",
+                "state_changes": {"morale_change": 4, "sanity_change": 2},
+                "prompt_hint": "这是偏正向的氛围事件，叙事里可以体现安全感和短暂放松。",
+            },
+            {
+                "event_id": "fog_pressures_in",
+                "category": "environment",
+                "title": "雾气压近",
+                "description": "潮湿的雾从地面漫上来，视野被一点点吞没，声音也变得含混。",
+                "location_types": ["wilderness", "dungeon"],
+                "time_slots": ["清晨", "黄昏", "夜晚", "深夜"],
+                "weathers": ["浓雾", "小雨"],
+                "severity": "medium",
+                "state_changes": {"sanity_change": -2},
+                "prompt_hint": "视野受限且不安感上升，叙事里应弱化远景、强调近距离感官细节。",
+            },
+        ]
+
+        # --- 玩家初始装备 ---
+        self.player.inventory = ["面包", "面包", "小型治疗药水"]
+        self.player.location = self.world.current_scene
 
     # ============================================================
     # 核心方法
@@ -846,28 +922,31 @@ class GameState:
         changes = _filtered
 
         # --- 玩家属性变更 ---
-        if "hp_change" in changes:
-            old_hp = self.player.hp
-            self.player.hp = clamp(
-                self.player.hp + int(changes["hp_change"]),
-                0,
-                self.player.max_hp,
-            )
-            change_log.append(f"HP: {old_hp} → {self.player.hp}")
-
-        if "mp_change" in changes:
-            old_mp = self.player.mp
-            self.player.mp = clamp(
-                self.player.mp + int(changes["mp_change"]),
-                0,
-                self.player.max_mp,
-            )
-            change_log.append(f"MP: {old_mp} → {self.player.mp}")
-
-        if "gold_change" in changes:
-            old_gold = self.player.gold
-            self.player.gold = max(0, self.player.gold + int(changes["gold_change"]))
-            change_log.append(f"金币: {old_gold} → {self.player.gold}")
+        if "hp_change" in changes:
+            old_hp = self.player.hp
+            self.player.hp = clamp(
+                self.player.hp + int(changes["hp_change"]),
+                0,
+                self.player.max_hp,
+            )
+            if self.player.hp != old_hp:
+                change_log.append(f"HP: {old_hp} → {self.player.hp}")
+
+        if "mp_change" in changes:
+            old_mp = self.player.mp
+            self.player.mp = clamp(
+                self.player.mp + int(changes["mp_change"]),
+                0,
+                self.player.max_mp,
+            )
+            if self.player.mp != old_mp:
+                change_log.append(f"MP: {old_mp} → {self.player.mp}")
+
+        if "gold_change" in changes:
+            old_gold = self.player.gold
+            self.player.gold = max(0, self.player.gold + int(changes["gold_change"]))
+            if self.player.gold != old_gold:
+                change_log.append(f"金币: {old_gold} → {self.player.gold}")
 
         if "exp_change" in changes:
             old_exp = self.player.experience
@@ -878,48 +957,53 @@ class GameState:
                 self._level_up()
                 change_log.append(f"升级！当前等级: {self.player.level}")
 
-        if "morale_change" in changes:
-            old_morale = self.player.morale
-            self.player.morale = clamp(
-                self.player.morale + int(changes["morale_change"]),
-                0, 100,
-            )
-            change_log.append(f"士气: {old_morale} → {self.player.morale}")
-
-        if "sanity_change" in changes:
-            old_sanity = self.player.sanity
-            self.player.sanity = clamp(
-                self.player.sanity + int(changes["sanity_change"]),
-                0, 100,
-            )
-            change_log.append(f"理智: {old_sanity} → {self.player.sanity}")
-
-        if "hunger_change" in changes:
-            old_hunger = self.player.hunger
-            self.player.hunger = clamp(
-                self.player.hunger + int(changes["hunger_change"]),
-                0, 100,
-            )
-            change_log.append(f"饱食度: {old_hunger} → {self.player.hunger}")
-
-        if "karma_change" in changes:
-            old_karma = self.player.karma
-            self.player.karma += int(changes["karma_change"])
-            change_log.append(f"善恶值: {old_karma} → {self.player.karma}")
-
-        # --- 位置变更 ---
-        if "new_location" in changes:
-            old_loc = self.player.location
-            new_loc = str(changes["new_location"])
-            self.player.location = new_loc
-            self.world.current_scene = new_loc
-            change_log.append(f"位置: {old_loc} → {new_loc}")
-            # 发现新地点
-            if new_loc not in self.world.discovered_locations:
-                self.world.discovered_locations.append(new_loc)
-                change_log.append(f"发现新地点: {new_loc}")
-                if new_loc in self.world.locations:
-                    self.world.locations[new_loc].is_discovered = True
+        if "morale_change" in changes:
+            old_morale = self.player.morale
+            self.player.morale = clamp(
+                self.player.morale + int(changes["morale_change"]),
+                0, 100,
+            )
+            if self.player.morale != old_morale:
+                change_log.append(f"士气: {old_morale} → {self.player.morale}")
+
+        if "sanity_change" in changes:
+            old_sanity = self.player.sanity
+            self.player.sanity = clamp(
+                self.player.sanity + int(changes["sanity_change"]),
+                0, 100,
+            )
+            if self.player.sanity != old_sanity:
+                change_log.append(f"理智: {old_sanity} → {self.player.sanity}")
+
+        if "hunger_change" in changes:
+            old_hunger = self.player.hunger
+            self.player.hunger = clamp(
+                self.player.hunger + int(changes["hunger_change"]),
+                0, 100,
+            )
+            if self.player.hunger != old_hunger:
+                change_log.append(f"饱食度: {old_hunger} → {self.player.hunger}")
+
+        if "karma_change" in changes:
+            old_karma = self.player.karma
+            self.player.karma += int(changes["karma_change"])
+            if self.player.karma != old_karma:
+                change_log.append(f"善恶值: {old_karma} → {self.player.karma}")
+
+        # --- 位置变更 ---
+        if "new_location" in changes:
+            old_loc = self.player.location
+            new_loc = str(changes["new_location"])
+            if new_loc.strip().lower() not in ("", "none", "null") and new_loc != old_loc:
+                self.player.location = new_loc
+                self.world.current_scene = new_loc
+                change_log.append(f"位置: {old_loc} → {new_loc}")
+                # 发现新地点
+                if new_loc not in self.world.discovered_locations:
+                    self.world.discovered_locations.append(new_loc)
+                    change_log.append(f"发现新地点: {new_loc}")
+                    if new_loc in self.world.locations:
+                        self.world.locations[new_loc].is_discovered = True
 
         # --- 物品变更 ---
         # 货币关键词列表：这些物品不进背包，而是直接转换为金币
@@ -1004,33 +1088,42 @@ class GameState:
                 change_log.append(f"移除状态: {name}")
 
         # --- NPC 相关变更 ---
-        if "npc_changes" in changes:
-            for npc_name, npc_data in changes["npc_changes"].items():
-                if npc_name in self.world.npcs:
-                    npc = self.world.npcs[npc_name]
-                    if "attitude" in npc_data:
-                        npc.attitude = str(npc_data["attitude"])
-                        change_log.append(f"NPC {npc_name} 态度变为: {npc.attitude}")
-                    if "is_alive" in npc_data:
-                        npc.is_alive = bool(npc_data["is_alive"])
-                        if not npc.is_alive:
-                            change_log.append(f"NPC {npc_name} 已死亡")
-                    if "relationship_change" in npc_data:
-                        old_rel = npc.relationship_level
-                        npc.relationship_level = clamp(
-                            npc.relationship_level + int(npc_data["relationship_change"]),
-                            -100, 100,
-                        )
-                        change_log.append(
-                            f"NPC {npc_name} 好感度: {old_rel} → {npc.relationship_level}"
-                        )
-                    if "hp_change" in npc_data:
-                        npc.hp = max(0, npc.hp + int(npc_data["hp_change"]))
-                        if npc.hp <= 0:
-                            npc.is_alive = False
-                            change_log.append(f"NPC {npc_name} 被击败")
-                    if "memory_add" in npc_data:
-                        npc.memory.append(str(npc_data["memory_add"]))
+        if "npc_changes" in changes:
+            for npc_name, npc_data in changes["npc_changes"].items():
+                if npc_name in self.world.npcs:
+                    npc = self.world.npcs[npc_name]
+                    if "attitude" in npc_data:
+                        new_attitude = str(npc_data["attitude"])
+                        if npc.attitude != new_attitude:
+                            npc.attitude = new_attitude
+                            change_log.append(f"NPC {npc_name} 态度变为: {npc.attitude}")
+                    if "is_alive" in npc_data:
+                        new_is_alive = bool(npc_data["is_alive"])
+                        was_alive = npc.is_alive
+                        if npc.is_alive != new_is_alive:
+                            npc.is_alive = new_is_alive
+                        if was_alive and not npc.is_alive:
+                            change_log.append(f"NPC {npc_name} 已死亡")
+                    if "relationship_change" in npc_data:
+                        old_rel = npc.relationship_level
+                        npc.relationship_level = clamp(
+                            npc.relationship_level + int(npc_data["relationship_change"]),
+                            -100, 100,
+                        )
+                        if npc.relationship_level != old_rel:
+                            change_log.append(
+                                f"NPC {npc_name} 好感度: {old_rel} → {npc.relationship_level}"
+                            )
+                    if "hp_change" in npc_data:
+                        old_hp = npc.hp
+                        npc.hp = max(0, npc.hp + int(npc_data["hp_change"]))
+                        if npc.hp <= 0:
+                            npc.is_alive = False
+                            change_log.append(f"NPC {npc_name} 被击败")
+                        elif npc.hp != old_hp:
+                            change_log.append(f"NPC {npc_name} HP: {old_hp} → {npc.hp}")
+                    if "memory_add" in npc_data:
+                        npc.memory.append(str(npc_data["memory_add"]))
 
         # --- 任务变更 ---
         if "quest_updates" in changes:
@@ -1054,30 +1147,45 @@ class GameState:
                         status_cn = _QUEST_STATUS_CN.get(quest.status, quest.status)
                         change_log.append(f"任务【{quest.title}】进展至\"{status_cn}\"")
 
-        # --- 世界状态变更 ---
-        if "weather_change" in changes:
-            self.world.weather = str(changes["weather_change"])
-            change_log.append(f"天气变为: {self.world.weather}")
-
-        if "time_change" in changes:
-            valid_times = ["清晨", "上午", "正午", "下午", "黄昏", "夜晚", "深夜"]
-            new_time = str(changes["time_change"])
-            if new_time in valid_times:
-                old_time = self.world.time_of_day
-                self.world.time_of_day = new_time
-                change_log.append(f"时间流逝: {old_time} → {self.world.time_of_day}")
-            else:
-                logger.warning(f"无效的 time_change 值 '{new_time}'，已忽略。合法值: {valid_times}")
-
-        if "global_flags_set" in changes:
-            for flag, value in changes["global_flags_set"].items():
-                self.world.global_flags[flag] = bool(value)
-                # 全局标记仅内部使用，不展示给用户
-                logger.info(f"全局标记设置: {flag} = {value}")
-
-        if "world_event" in changes:
-            self.world.world_events.append(str(changes["world_event"]))
-            change_log.append(f"世界事件: {changes['world_event']}")
+        # --- 世界状态变更 ---
+        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
+                    change_log.append(f"天气变为: {self.world.weather}")
+            else:
+                logger.warning(f"无效的 weather_change 值 '{new_weather}'，已忽略。")
+
+        if "time_change" in changes:
+            valid_times = ["清晨", "上午", "正午", "下午", "黄昏", "夜晚", "深夜"]
+            new_time = str(changes["time_change"])
+            if new_time in valid_times:
+                old_time = self.world.time_of_day
+                if new_time != old_time:
+                    self.world.time_of_day = new_time
+                    change_log.append(f"时间流逝: {old_time} → {self.world.time_of_day}")
+            else:
+                logger.warning(f"无效的 time_change 值 '{new_time}'，已忽略。合法值: {valid_times}")
+
+        if "weather_change" in changes or "time_change" in changes:
+            old_light = self.world.light_level
+            self.world.light_level = self._determine_light_level()
+            if old_light != self.world.light_level:
+                change_log.append(f"光照变化: {old_light} → {self.world.light_level}")
+
+        if "global_flags_set" in changes:
+            for flag, value in changes["global_flags_set"].items():
+                self.world.global_flags[flag] = bool(value)
+                # 全局标记仅内部使用，不展示给用户
+                logger.info(f"全局标记设置: {flag} = {value}")
+
+        if "world_event" in changes:
+            world_event = str(changes["world_event"])
+            if not self.world.world_events or self.world.world_events[-1] != world_event:
+                self.world.world_events.append(world_event)
+                change_log.append(f"世界事件: {world_event}")
 
         # --- 装备变更 ---
         if "equip" in changes:
@@ -1298,16 +1406,19 @@ class GameState:
         if self.world.rumors:
             rumors_desc = "\n【流传的传闻】\n" + "\n".join(f"  - {r}" for r in self.world.rumors[-3:])
 
-        # 8. 随机事件
-        random_event_desc = ""
-        if getattr(self, 'pending_random_event', None):
-            random_event_desc = (
-                f"\n【本回合随机事件 —— 必须融入本次叙事】\n"
-                f"{self.pending_random_event}\n"
-                f"请将此事件自然地融入剧情描写中，作为额外的意外插曲。"
-                f"玩家可以选择回应或忽视此事件。至少一个选项应与此事件相关。"
-            )
-            self.pending_random_event = None  # 用后清除
+        # 8. 显式环境事件
+        environment_event_desc = ""
+        if self.pending_environment_event:
+            env = self.pending_environment_event
+            environment_event_desc = (
+                f"\n【本回合环境事件 —— 必须融入本次叙事】\n"
+                f"[{env.category.upper()}|{env.severity}] {env.title}\n"
+                f"{env.description}\n"
+                f"{env.prompt_hint}\n"
+                f"请将此事件自然地融入剧情描写中，作为本回合可感知的环境变化。"
+                f"玩家可以选择回应、调查、规避或忽视它。至少一个选项应与此事件相关。"
+            )
+            self.pending_environment_event = None  # 用后清除
 
         # 9. 一致性约束指令
         consistency_rules = (
@@ -1339,13 +1450,13 @@ class GameState:
             scene_desc,
             player_desc,
             npc_desc,
-            quest_desc,
-            move_desc,
-            event_desc,
-            rumors_desc,
-            random_event_desc,
-            consistency_rules,
-        ])
+            quest_desc,
+            move_desc,
+            event_desc,
+            rumors_desc,
+            environment_event_desc,
+            consistency_rules,
+        ])
 
         return full_prompt
 
@@ -1419,20 +1530,21 @@ class GameState:
                         f"矛盾: 物品 '{item}' 不是消耗品，使用后不应消失。请将其从 items_lost 中移除。"
                     )
 
-        # 检测3: 位置移动是否合法
-        if "new_location" in proposed_changes:
-            target = str(proposed_changes["new_location"])
-            current_loc = self.world.locations.get(self.player.location)
-            if current_loc and target not in current_loc.connected_to:
-                contradictions.append(
-                    f"矛盾: 试图移动到不相邻的地点 '{target}'（当前位置: {self.player.location}）"
-                )
-            target_loc = self.world.locations.get(target)
-            if target_loc and not target_loc.is_accessible:
-                if target_loc.required_item and target_loc.required_item not in self.player.inventory:
-                    contradictions.append(
-                        f"矛盾: 地点 '{target}' 被锁定，需要 '{target_loc.required_item}'"
-                    )
+        # 检测3: 位置移动是否合法
+        if "new_location" in proposed_changes:
+            target = str(proposed_changes["new_location"])
+            if target.strip().lower() not in ("", "none", "null") and target != self.player.location:
+                current_loc = self.world.locations.get(self.player.location)
+                if current_loc and target not in current_loc.connected_to:
+                    contradictions.append(
+                        f"矛盾: 试图移动到不相邻的地点 '{target}'（当前位置: {self.player.location}）"
+                    )
+                target_loc = self.world.locations.get(target)
+                if target_loc and not target_loc.is_accessible:
+                    if target_loc.required_item and target_loc.required_item not in self.player.inventory:
+                        contradictions.append(
+                            f"矛盾: 地点 '{target}' 被锁定，需要 '{target_loc.required_item}'"
+                        )
 
         # 检测4: 金币是否足够（如果是消费操作）
         if "gold_change" in proposed_changes:
@@ -1589,64 +1701,296 @@ class GameState:
             return True
         return False
 
-    def tick_time(self) -> list[str]:
-        """
-        推进游戏时间（每回合调用）。
-
-        设计思路：
-        - 回合数递增
-        - 时间段按固定顺序轮转
-        - 每过一个完整日夜循环，天数+1
-        - 自动减少饱食度，模拟饥饿机制
-        - 结算状态效果持续时间
-        - 检查限时任务
-
-        Returns:
-            tick_log: 本回合时间流逝引起的状态变化描述列表
-        """
-        tick_log: list[str] = []
-        self.turn += 1
-
-        # 时间推进
-        time_sequence = ["清晨", "上午", "正午", "下午", "黄昏", "夜晚", "深夜"]
-        current_idx = time_sequence.index(self.world.time_of_day) if self.world.time_of_day in time_sequence else 0
-        next_idx = (current_idx + 1) % len(time_sequence)
-        old_time = self.world.time_of_day
-        self.world.time_of_day = time_sequence[next_idx]
-        tick_log.append(f"时间流逝: {old_time} → {self.world.time_of_day}")
-
-        # 新的一天
-        if next_idx == 0:
-            self.world.day_count += 1
-            tick_log.append(f"新的一天！第 {self.world.day_count} 天")
-            logger.info(f"新的一天开始了！第 {self.world.day_count} 天")
-
-        # 饱食度衰减（每回合 -3）
-        old_hunger = self.player.hunger
-        self.player.hunger = max(0, self.player.hunger - 3)
-        if old_hunger != self.player.hunger:
-            tick_log.append(f"饱食度自然衰减: {old_hunger} → {self.player.hunger}")
-        if self.player.hunger <= 0:
-            tick_log.append("极度饥饿！属性受到惩罚")
-            logger.info("玩家非常饥饿，属性受到惩罚")
-
-        # 结算状态效果
-        effect_log = self._apply_status_effects()
-        tick_log.extend(effect_log)
-
-        # 检查限时任务
-        self._check_quest_deadlines()
-
-        # 更新 NPC 位置（根据时间表）
-        self._update_npc_schedules()
-
-        # 随机事件（约 25% 概率触发）
-        self._roll_random_event()
-
-        return tick_log
-
-    def _apply_status_effects(self) -> list[str]:
-        """每回合结算状态效果：应用修正、递减持续时间、移除过期效果
+    def tick_time(self, player_intent: Optional[dict] = None) -> list[str]:
+        """
+        按动作消耗推进游戏时间。
+
+        设计思路：
+        - 回合数递增
+        - 不同动作消耗不同的时间点数
+        - 累积点数达到阈值时，时间段按固定顺序轮转
+        - 每过一个完整日夜循环，天数+1
+        - 自动减少饱食度，模拟饥饿机制
+        - 结算状态效果持续时间
+        - 检查限时任务
+
+        Returns:
+            tick_log: 本回合时间流逝引起的状态变化描述列表
+        """
+        tick_log: list[str] = []
+        self.turn += 1
+        time_threshold = 2
+        action_units = self._estimate_time_cost_units(player_intent)
+        self.world.time_progress_units += action_units
+        elapsed_segments = self.world.time_progress_units // time_threshold
+        self.world.time_progress_units = self.world.time_progress_units % time_threshold
+
+        if elapsed_segments <= 0:
+            return tick_log
+
+        time_sequence = ["清晨", "上午", "正午", "下午", "黄昏", "夜晚", "深夜"]
+        for _ in range(elapsed_segments):
+            current_idx = (
+                time_sequence.index(self.world.time_of_day)
+                if self.world.time_of_day in time_sequence
+                else 0
+            )
+            next_idx = (current_idx + 1) % len(time_sequence)
+            old_time = self.world.time_of_day
+            self.world.time_of_day = time_sequence[next_idx]
+            tick_log.append(f"时间流逝: {old_time} → {self.world.time_of_day}")
+
+            if next_idx == 0:
+                self.world.day_count += 1
+                tick_log.append(f"新的一天！第 {self.world.day_count} 天")
+                logger.info(f"新的一天开始了！第 {self.world.day_count} 天")
+
+        old_hunger = self.player.hunger
+        self.player.hunger = max(0, self.player.hunger - (3 * elapsed_segments))
+        if old_hunger != self.player.hunger:
+            tick_log.append(f"饱食度自然衰减: {old_hunger} → {self.player.hunger}")
+        if self.player.hunger <= 0:
+            tick_log.append("极度饥饿！属性受到惩罚")
+            logger.info("玩家非常饥饿，属性受到惩罚")
+
+        for _ in range(elapsed_segments):
+            effect_log = self._apply_status_effects()
+            tick_log.extend(effect_log)
+
+            # 检查限时任务
+            self._check_quest_deadlines()
+
+            # 更新 NPC 位置（根据时间表）
+            self._update_npc_schedules()
+
+        # 显式环境系统：光照 / 天气 / 环境扰动
+        self._update_environment_cycle(tick_log)
+
+        return tick_log
+
+    def _estimate_time_cost_units(self, player_intent: Optional[dict] = None) -> int:
+        """Estimate how much in-world time a player action should consume."""
+        if not isinstance(player_intent, dict):
+            return 2
+
+        intent = str(player_intent.get("intent", "")).upper()
+        raw_input = str(player_intent.get("raw_input", "") or "")
+        details = str(player_intent.get("details", "") or "")
+        target = str(player_intent.get("target", "") or "")
+        full_text = f"{raw_input} {details} {target}"
+
+        base_costs = {
+            "TALK": 0,
+            "TRADE": 1,
+            "USE_ITEM": 1,
+            "EQUIP": 1,
+            "SKILL": 1,
+            "MOVE": 2,
+            "EXPLORE": 2,
+            "QUEST": 2,
+            "ATTACK": 2,
+            "REST": 4,
+            "WAIT": 4,
+        }
+        cost = base_costs.get(intent, 1)
+
+        lightweight_markers = (
+            "检查",
+            "查看",
+            "确认",
+            "翻看",
+            "端详",
+            "研究",
+            "询问",
+            "交谈",
+            "背包",
+            "物品",
+            "装备",
+            "地图",
+        )
+        if intent in {"EXPLORE", "QUEST"} and any(marker in full_text for marker in lightweight_markers):
+            return 0
+
+        return max(0, cost)
+
+    def _determine_light_level(self) -> str:
+        """Derive current light level from time of day and weather."""
+        base_levels = {
+            "清晨": "柔和",
+            "上午": "明亮",
+            "正午": "明亮",
+            "下午": "柔和",
+            "黄昏": "昏暗",
+            "夜晚": "幽暗",
+            "深夜": "漆黑",
+        }
+        ordered_levels = ["明亮", "柔和", "昏暗", "幽暗", "漆黑"]
+        weather_penalty = {
+            "晴朗": 0,
+            "多云": 0,
+            "小雨": 1,
+            "大雪": 1,
+            "浓雾": 1,
+            "暴风雨": 2,
+        }
+
+        base_level = base_levels.get(self.world.time_of_day, "柔和")
+        current_index = ordered_levels.index(base_level)
+        darker_by = weather_penalty.get(self.world.weather, 0)
+        next_index = min(len(ordered_levels) - 1, current_index + darker_by)
+        return ordered_levels[next_index]
+
+    def _update_environment_cycle(self, tick_log: list[str]):
+        """Advance light/weather and roll explicit environment events."""
+        self.pending_environment_event = None
+        self._update_light_level_event(tick_log)
+        self._maybe_shift_weather(tick_log)
+        self._update_light_level_event(tick_log)
+        self._roll_environment_event(tick_log)
+
+    def _update_light_level_event(self, tick_log: list[str]):
+        old_light = self.world.light_level
+        new_light = self._determine_light_level()
+        if new_light == old_light:
+            return
+
+        self.world.light_level = new_light
+        event = EnvironmentEvent(
+            event_id=f"light-{self.turn}",
+            category="light",
+            title=f"光照转为{new_light}",
+            description=f"随着时间与天气变化，周围环境现在呈现出{new_light}的光照状态。",
+            location=self.player.location,
+            time_of_day=self.world.time_of_day,
+            weather=self.world.weather,
+            light_level=new_light,
+            severity="medium" if new_light in {"幽暗", "漆黑"} else "low",
+            prompt_hint="请在叙事中体现能见度、阴影和角色主观感受的变化。",
+        )
+        self._register_environment_event(
+            event,
+            tick_log,
+            inject_prompt=new_light in {"昏暗", "幽暗", "漆黑"},
+        )
+
+    def _maybe_shift_weather(self, tick_log: list[str]):
+        """Occasionally shift weather to keep the environment dynamic."""
+        chance = 0.18 if self.world.time_of_day in {"清晨", "黄昏"} else 0.08
+        if random.random() >= chance:
+            return
+
+        weather_transitions = {
+            "晴朗": ["多云", "小雨"],
+            "多云": ["晴朗", "���雨", "浓雾"],
+            "小雨": ["多云", "暴风雨", "浓雾"],
+            "浓雾": ["多云", "小雨", "晴朗"],
+            "暴风雨": ["小雨", "多云"],
+            "大雪": ["多云"],
+        }
+        next_candidates = weather_transitions.get(self.world.weather, ["晴朗", "多云"])
+        new_weather = random.choice(next_candidates)
+        if new_weather == self.world.weather:
+            return
+
+        loc = self.world.locations.get(self.player.location)
+        weather_effects: dict[str, Any] = {"weather_change": new_weather}
+        if loc and loc.location_type in {"wilderness", "dungeon"}:
+            if new_weather == "暴风雨":
+                weather_effects.update({"morale_change": -3, "sanity_change": -2})
+            elif new_weather == "浓雾":
+                weather_effects.update({"sanity_change": -1})
+            elif new_weather == "晴朗" and self.world.weather in {"小雨", "浓雾", "暴风雨"}:
+                weather_effects.update({"morale_change": 2})
+
+        event = EnvironmentEvent(
+            event_id=f"weather-{self.turn}",
+            category="weather",
+            title=f"天气转为{new_weather}",
+            description=f"周围的天象正在变化，空气与视野都随着天气转向{new_weather}。",
+            location=self.player.location,
+            time_of_day=self.world.time_of_day,
+            weather=new_weather,
+            light_level=self.world.light_level,
+            severity="medium" if new_weather in {"暴风雨", "浓雾"} else "low",
+            state_changes=weather_effects,
+            prompt_hint="请把天气变化作为当前回合的重要氛围来源，影响角色观察和选择。",
+        )
+        self._register_environment_event(event, tick_log, inject_prompt=True)
+        self.world.light_level = self._determine_light_level()
+
+    def _roll_environment_event(self, tick_log: list[str]):
+        """Roll a structured environment event using explicit template filters."""
+        loc = self.world.locations.get(self.player.location)
+        if loc is None or not self.environment_event_pool:
+            return
+
+        chance = 0.08
+        if loc.danger_level >= 3:
+            chance += 0.08
+        if self.world.light_level in {"幽暗", "漆黑"}:
+            chance += 0.06
+        if self.world.weather in {"暴风雨", "浓雾"}:
+            chance += 0.04
+        if random.random() >= chance:
+            return
+
+        candidates: list[dict[str, Any]] = []
+        for template in self.environment_event_pool:
+            if template.get("location_types") and loc.location_type not in template["location_types"]:
+                continue
+            if template.get("time_slots") and self.world.time_of_day not in template["time_slots"]:
+                continue
+            if template.get("weathers") and self.world.weather not in template["weathers"]:
+                continue
+            if template.get("requires_rest_available") and not loc.rest_available:
+                continue
+            if loc.danger_level < int(template.get("min_danger", 0)):
+                continue
+            candidates.append(template)
+
+        if not candidates:
+            return
+
+        template = random.choice(candidates)
+        event = EnvironmentEvent(
+            event_id=f"{template['event_id']}-{self.turn}",
+            category=str(template.get("category", "environment")),
+            title=str(template.get("title", "环境异动")),
+            description=str(template.get("description", "")),
+            location=self.player.location,
+            time_of_day=self.world.time_of_day,
+            weather=self.world.weather,
+            light_level=self.world.light_level,
+            severity=str(template.get("severity", "low")),
+            state_changes=copy.deepcopy(template.get("state_changes", {})),
+            prompt_hint=str(template.get("prompt_hint", "")),
+        )
+        self._register_environment_event(event, tick_log, inject_prompt=True)
+
+    def _register_environment_event(
+        self,
+        event: EnvironmentEvent,
+        tick_log: list[str],
+        *,
+        inject_prompt: bool,
+    ):
+        """Persist an environment event, optionally inject it into the next prompt, and apply effects."""
+        self.world.recent_environment_events.append(event)
+        self.world.recent_environment_events = self.world.recent_environment_events[-8:]
+        if inject_prompt:
+            self.pending_environment_event = event
+
+        if event.category == "light":
+            tick_log.append(f"光照变化: {event.title}")
+
+        changes = copy.deepcopy(event.state_changes)
+        changes.setdefault("world_event", event.title)
+        change_log = self.apply_changes(changes)
+        tick_log.extend(change_log)
+        logger.info("环境事件触发: %s", event.title)
+
+    def _apply_status_effects(self) -> list[str]:
+        """每回合结算状态效果：应用修正、递减持续时间、移除过期效果
 
         Returns:
             effect_log: 状态效果结算引起的变化描述列表
@@ -1709,17 +2053,8 @@ class GameState:
 
         return effect_log
 
-    def _roll_random_event(self):
-        """以一定概率从事件池中抽取一个随机事件，注入到下一次 Prompt 中"""
-        import random
-        self.pending_random_event = None
-        if self.random_event_pool and random.random() < 0.25:
-            event = random.choice(self.random_event_pool)
-            self.pending_random_event = event
-            logger.info(f"随机事件触发: {event}")
-
-    def _check_quest_deadlines(self):
-        """检查限时任务是否过期"""
+    def _check_quest_deadlines(self):
+        """检查限时任务是否过期"""
         for quest in self.world.quests.values():
             if quest.status == "active" and quest.turns_remaining > 0:
                 quest.turns_remaining -= 1
@@ -1920,3 +2255,22 @@ class GameState:
         if self.player.sanity < 100:
             filtered["sanity_change"] = base_recovery["sanity_change"]
         return filtered
+
+    def get_environment_snapshot(self, limit: int = 3) -> dict[str, Any]:
+        """Return a compact environment summary for UI and logs."""
+        loc = self.world.locations.get(self.player.location)
+        recent_events = [
+            event.model_dump()
+            for event in self.world.recent_environment_events[-limit:]
+        ]
+        return {
+            "weather": self.world.weather,
+            "light_level": self.world.light_level,
+            "time_of_day": self.world.time_of_day,
+            "season": self.world.season,
+            "location_type": loc.location_type if loc else "unknown",
+            "danger_level": loc.danger_level if loc else 0,
+            "rest_available": bool(loc.rest_available) if loc else False,
+            "shop_available": bool(loc.shop_available) if loc else False,
+            "recent_events": recent_events,
+        }

story_engine.py

@@ -525,7 +525,7 @@ class StoryEngine:
         #   2. apply_changes 的 change_log 与状态栏显示一致
         #   3. 不会出现“文本说100、状态栏显示97”的同步Bug
         # ============================================
-        tick_log = self.game_state.tick_time()
+        tick_log = self.game_state.tick_time(player_intent)
 
         # ============================================
         # 第一阶段：生成剧情大纲
@@ -1032,49 +1032,222 @@ class StoryEngine:
             ),
         }
 
-    def _sanitize_state_changes(self, changes: dict, event_type: str = "") -> tuple[dict, list[str]]:
-        """
-        清理状态变更：阻止非消耗品因使用而被移除。
-
-        规则：
-        - 交易(TRADE)、赠送、丢弃等行为可以移除任何物品
-        - 其他行为（使用、探索、对话等）只能移除消耗品
-
-        Args:
-            changes: 状态变更字典
-            event_type: 事件类型（来自大纲）
-
-        Returns:
-            (清理后的changes, 警告列表)
-        """
-        warnings = []
-        if "items_lost" not in changes:
-            return changes, warnings
-
-        # 交易/赠送行为可以移除任何物品
-        trade_events = {"TRADE", "GIVE", "DROP"}
-        if event_type.upper() in trade_events:
-            return changes, warnings
-
-        # 其他行为：只允许移除消耗品
-        changes = dict(changes)  # 浅拷贝，避免修改原始数据
-        sanitized_items_lost = []
-        for item_name in changes["items_lost"]:
-            item_str = str(item_name)
-            if self.game_state.is_item_consumable(item_str):
-                sanitized_items_lost.append(item_name)
-            else:
-                warnings.append(
-                    f"物品 '{item_str}' 不是消耗品，使用后仍保留在背包中"
-                )
-                logger.warning(f"阻止移除非消耗品: {item_str}")
-
-        if sanitized_items_lost:
-            changes["items_lost"] = sanitized_items_lost
-        else:
-            changes.pop("items_lost", None)
+    def _sanitize_state_changes(self, changes: dict, event_type: str = "") -> tuple[dict, list[str]]:
+        """
+        清理状态变更，避免非预期的高风险副作用进入正式状态。
+
+        规则：
+        - 交易(TRADE)、赠送、丢弃等行为可以移除任何物品
+        - 其他行为（使用、探索、对话等）只能移除消耗品
+        - 非战斗事件不能直接造成 NPC 死亡
+
+        Args:
+            changes: 状态变更字典
+            event_type: 事件类型（来自大纲）
 
-        return changes, warnings
+        Returns:
+            (清理后的changes, 警告列表)
+        """
+        warnings = []
+        changes = dict(changes)
+
+        if "items_lost" in changes:
+            # 交易/赠送行为可以移除任何物品
+            trade_events = {"TRADE", "GIVE", "DROP"}
+            if event_type.upper() not in trade_events:
+                # 其他行为：只允许移除消耗品
+                sanitized_items_lost = []
+                for item_name in changes["items_lost"]:
+                    item_str = str(item_name)
+                    if self.game_state.is_item_consumable(item_str):
+                        sanitized_items_lost.append(item_name)
+                    else:
+                        warnings.append(
+                            f"物品 '{item_str}' 不是消耗品，使用后仍保留在背包中"
+                        )
+                        logger.warning(f"阻止移除非消耗品: {item_str}")
+
+                if sanitized_items_lost:
+                    changes["items_lost"] = sanitized_items_lost
+                else:
+                    changes.pop("items_lost", None)
+
+        changes, item_warnings = self._sanitize_controlled_item_changes(changes, event_type)
+        warnings.extend(item_warnings)
+        changes, npc_warnings = self._sanitize_noncombat_npc_changes(changes, event_type)
+        warnings.extend(npc_warnings)
+
+        return changes, warnings
+
+    def _sanitize_controlled_item_changes(
+        self,
+        changes: dict,
+        event_type: str = "",
+    ) -> tuple[dict, list[str]]:
+        """Restrict item gain/equip to registered items and paid trade outcomes."""
+        sanitized_changes = dict(changes)
+        warnings: list[str] = []
+        registered_items = set(self.game_state.world.item_registry.keys())
+        inventory_items = set(self.game_state.player.inventory)
+        equipped_items = {
+            str(item)
+            for item in self.game_state.player.equipment.values()
+            if item and str(item).lower() not in {"none", "null", ""}
+        }
+        allowed_trade_items = {
+            str(item_name)
+            for npc in self.game_state.world.npcs.values()
+            if npc.can_trade
+            for item_name in npc.shop_inventory
+        }
+
+        original_items_gained = [
+            str(item)
+            for item in sanitized_changes.get("items_gained", [])
+        ]
+        valid_items_gained: list[str] = []
+        for item_name in original_items_gained:
+            if item_name not in registered_items:
+                warning = f"移除未注册物品获取: {item_name}"
+                warnings.append(warning)
+                logger.warning(warning)
+                continue
+            if event_type.upper() == "TRADE" and allowed_trade_items and item_name not in allowed_trade_items:
+                warning = f"移除不在商店配置中的交易物品: {item_name}"
+                warnings.append(warning)
+                logger.warning(warning)
+                continue
+            valid_items_gained.append(item_name)
+
+        if valid_items_gained:
+            sanitized_changes["items_gained"] = valid_items_gained
+        else:
+            sanitized_changes.pop("items_gained", None)
+
+        if event_type.upper() == "TRADE":
+            gold_change = sanitized_changes.get("gold_change")
+            items_lost = sanitized_changes.get("items_lost", [])
+            is_paid_trade = (
+                isinstance(gold_change, (int, float)) and gold_change < 0
+            ) or bool(items_lost)
+            if not is_paid_trade:
+                if "items_gained" in sanitized_changes:
+                    warning = "移除未支付的交易物品获取"
+                    warnings.append(warning)
+                    logger.warning(warning)
+                    sanitized_changes.pop("items_gained", None)
+                if "equip" in sanitized_changes:
+                    warning = "移除未支付的交易装备变更"
+                    warnings.append(warning)
+                    logger.warning(warning)
+                    sanitized_changes.pop("equip", None)
+
+        if "equip" in sanitized_changes and isinstance(sanitized_changes["equip"], dict):
+            valid_equippable = inventory_items | equipped_items | set(
+                sanitized_changes.get("items_gained", [])
+            )
+            sanitized_equip: dict[str, str] = {}
+            for slot, item_name in sanitized_changes["equip"].items():
+                item_str = str(item_name)
+                if item_str.lower() in {"none", "null", ""}:
+                    sanitized_equip[str(slot)] = item_name
+                    continue
+                if item_str not in registered_items:
+                    warning = f"移除未注册装备变更: {slot} -> {item_str}"
+                    warnings.append(warning)
+                    logger.warning(warning)
+                    continue
+                if event_type.upper() == "TRADE" and allowed_trade_items and item_str not in allowed_trade_items:
+                    warning = f"移除不在商店配置中的交易装备: {slot} -> {item_str}"
+                    warnings.append(warning)
+                    logger.warning(warning)
+                    continue
+                if item_str not in valid_equippable:
+                    warning = f"移除未持有装备变更: {slot} -> {item_str}"
+                    warnings.append(warning)
+                    logger.warning(warning)
+                    continue
+                sanitized_equip[str(slot)] = item_str
+
+            if sanitized_equip:
+                sanitized_changes["equip"] = sanitized_equip
+            else:
+                sanitized_changes.pop("equip", None)
+
+        return sanitized_changes, warnings
+
+    def _sanitize_noncombat_npc_changes(
+        self,
+        changes: dict,
+        event_type: str = "",
+    ) -> tuple[dict, list[str]]:
+        """移除非战斗事件中意外出现的 NPC 致死变更。"""
+        npc_changes = changes.get("npc_changes")
+        if not isinstance(npc_changes, dict):
+            return changes, []
+
+        noncombat_events = {
+            "TRADE",
+            "GIVE",
+            "DROP",
+            "TALK",
+            "DIALOGUE",
+            "MOVE",
+            "EXPLORE",
+            "REST",
+            "DISCOVERY",
+        }
+        if event_type.upper() not in noncombat_events:
+            return changes, []
+
+        sanitized_changes = dict(changes)
+        sanitized_npc_changes: dict[str, dict] = {}
+        warnings: list[str] = []
+
+        for npc_name, npc_data in npc_changes.items():
+            if not isinstance(npc_data, dict):
+                sanitized_npc_changes[str(npc_name)] = npc_data
+                continue
+
+            cleaned_data = dict(npc_data)
+            removed_keys: list[str] = []
+
+            if cleaned_data.get("is_alive") is False:
+                cleaned_data.pop("is_alive", None)
+                removed_keys.append("is_alive")
+
+            hp_delta = cleaned_data.get("hp_change")
+            npc = self.game_state.world.npcs.get(str(npc_name))
+            try:
+                hp_delta_value = int(hp_delta) if hp_delta is not None else None
+            except (TypeError, ValueError):
+                hp_delta_value = None
+
+            if (
+                hp_delta_value is not None
+                and npc is not None
+                and npc.hp + hp_delta_value <= 0
+            ):
+                cleaned_data.pop("hp_change", None)
+                removed_keys.append("hp_change")
+
+            if removed_keys:
+                warning = (
+                    f"移除非战斗事件中的 NPC 致死变更: {npc_name} -> "
+                    f"{', '.join(removed_keys)}"
+                )
+                warnings.append(warning)
+                logger.warning(warning)
+
+            if cleaned_data:
+                sanitized_npc_changes[str(npc_name)] = cleaned_data
+
+        if sanitized_npc_changes:
+            sanitized_changes["npc_changes"] = sanitized_npc_changes
+        else:
+            sanitized_changes.pop("npc_changes", None)
+
+        return sanitized_changes, warnings
 
     def _fill_missing_consumable_effects(
         self,
@@ -1396,7 +1569,7 @@ class StoryEngine:
         logger.info(f"[流式/合并] 生成故事响应，玩家意图: {player_intent}")
 
         # 推进时间
-        tick_log = self.game_state.tick_time()
+        tick_log = self.game_state.tick_time(player_intent)
 
         # 构建合并 Prompt
         system_prompt = MERGED_SYSTEM_PROMPT_TEMPLATE.format(