156_游戏开发：NPC对话生成 - 实时交互环境下的智能对话上下文保持与多模态融合技术实践

┌───────────────────────────────────────────────────────────────────┐
│                         游戏引擎集成层                             │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐            │
│  │  对话触发器   │  │  环境状态同步 │  │  动画/语音控制 │            │
│  └──────────────┘  └──────────────┘  └──────────────┘            │
└───────────────────────┬───────────────────────────────────────────┘
                        │
┌───────────────────────▼───────────────────────────────────────────┐
│                         对话管理层                                │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐            │
│  │  上下文管理   │  │  记忆系统    │  │  对话流控制   │            │
│  └──────────────┘  └──────────────┘  └──────────────┘            │
└───────────────────────┬───────────────────────────────────────────┘
                        │
┌───────────────────────▼───────────────────────────────────────────┐
│                         LLM处理层                                 │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐            │
│  │  提示工程    │  │  LLM推理     │  │  输出解析     │            │
│  └──────────────┘  └──────────────┘  └──────────────┘            │
└───────────────────────┬───────────────────────────────────────────┘
                        │
┌───────────────────────▼───────────────────────────────────────────┐
│                         数据持久层                                │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐            │
│  │  对话历史    │  │  NPC配置     │  │  游戏知识图谱  │            │
│  └──────────────┘  └──────────────┘  └──────────────┘            │
└───────────────────────────────────────────────────────────────────┘

┌───────────────────────────────────────────────────────────────────┐
│                         记忆检索与组织                              │
└───────────────────────┬───────────────────────────────────────────┘
                        │
┌──────────────┐ ┌──────▼───────┐ ┌────────────────┐
│  短期记忆    │ │   中期记忆    │ │    长期记忆    │
│ (工作记忆)   │ │   (情节记忆)  │ │    (语义记忆)  │
│  最近对话    │ │   重要事件    │ │  角色背景/知识  │
│  10-20轮     │ │   24小时内    │ │    持久化      │
└──────────────┘ └──────────────┘ └────────────────┘

import numpy as np
from sentence_transformers import SentenceTransformer

class NPCMemorySystem:
    def __init__(self, embedding_model_name="all-MiniLM-L6-v2"):
        self.embedding_model = SentenceTransformer(embedding_model_name)
        self.short_term_memory = []  # 最近对话
        self.mid_term_memory = []    # 重要事件
        self.long_term_memory = []   # 角色背景/知识
        
        # 记忆重要性权重
        self.importance_threshold = 0.7
        
        # 记忆容量限制
        self.short_term_capacity = 20
        self.mid_term_capacity = 100
    
    def encode_memory(self, content, importance_score=0.5, timestamp=None):
        """编码记忆条目"""
        if timestamp is None:
            timestamp = time.time()
            
        embedding = self.embedding_model.encode(content)
        
        memory_item = {
            'content': content,
            'embedding': embedding,
            'importance_score': importance_score,
            'timestamp': timestamp,
            'recall_count': 0,
            'last_recall_timestamp': None
        }
        
        return memory_item
    
    def store_memory(self, content, importance_score=0.5, is_long_term=False):
        """存储记忆到适当的记忆层级"""
        memory_item = self.encode_memory(content, importance_score)
        
        # 添加到短期记忆
        self.short_term_memory.append(memory_item)
        if len(self.short_term_memory) > self.short_term_capacity:
            # 移除最旧的记忆
            self.short_term_memory.pop(0)
        
        # 根据重要性决定是否升级到中期记忆
        if importance_score >= self.importance_threshold:
            self.mid_term_memory.append(memory_item)
            if len(self.mid_term_memory) > self.mid_term_capacity:
                # 根据重要性和时间戳排序并移除不重要的记忆
                self.mid_term_memory.sort(key=lambda x: (x['importance_score'], x['timestamp']), reverse=True)
                self.mid_term_memory = self.mid_term_memory[:self.mid_term_capacity]
        
        # 长期记忆由游戏设计师预设或在关键时刻添加
        if is_long_term:
            self.long_term_memory.append(memory_item)
    
    def retrieve_relevant_memories(self, query, max_results=5):
        """检索与当前查询相关的记忆"""
        query_embedding = self.embedding_model.encode(query)
        
        # 合并所有记忆
        all_memories = self.short_term_memory + self.mid_term_memory + self.long_term_memory
        
        # 计算相似度并排序
        for memory in all_memories:
            memory['similarity'] = np.dot(query_embedding, memory['embedding']) / (
                np.linalg.norm(query_embedding) * np.linalg.norm(memory['embedding'])
            )
        
        # 根据相似度排序
        relevant_memories = sorted(all_memories, key=lambda x: x['similarity'], reverse=True)
        
        # 更新检索计数
        for memory in relevant_memories[:max_results]:
            memory['recall_count'] += 1
            memory['last_recall_timestamp'] = time.time()
        
        return relevant_memories[:max_results]
    
    def summarize_context(self, query, max_context_length=1000):
        """生成适合LLM输入的上下文摘要"""
        relevant_memories = self.retrieve_relevant_memories(query)
        
        # 构建上下文
        context_parts = []
        total_length = 0
        
        # 首先添加长期记忆（角色背景）
        for memory in self.long_term_memory:
            if len(context_parts) == 0:  # 只添加最重要的长期记忆
                context_parts.append(f"[背景知识] {memory['content']}")
                total_length += len(memory['content'])
                break
        
        # 然后添加中期记忆中的重要事件
        for memory in sorted([m for m in relevant_memories if m in self.mid_term_memory],
                            key=lambda x: x['importance_score'], reverse=True)[:2]:
            if total_length + len(memory['content']) < max_context_length:
                context_parts.append(f"[重要事件] {memory['content']}")
                total_length += len(memory['content'])
        
        # 最后添加短期记忆中的最近对话
        recent_conversations = sorted([m for m in self.short_term_memory], 
                                    key=lambda x: x['timestamp'], reverse=True)
        
        for memory in recent_conversations:
            if total_length + len(memory['content']) < max_context_length:
                context_parts.append(memory['content'])
                total_length += len(memory['content'])
            else:
                break
        
        return "\n".join(reversed(context_parts))  # 按时间顺序排列

class ConversationTracker:
    def __init__(self):
        self.current_topic = None
        self.topic_history = []
        self.topic_transition_threshold = 0.6
        self.max_topic_history = 5
    
    def update_topic(self, user_input, embedding_model):
        """更新当前对话主题"""
        input_embedding = embedding_model.encode(user_input)
        
        if self.current_topic is None:
            # 设置第一个主题
            self.current_topic = {
                'topic': user_input[:50],  # 简短描述
                'embedding': input_embedding,
                'start_time': time.time(),
                'utterances': 1
            }
            self.topic_history.append(self.current_topic)
        else:
            # 计算与当前主题的相似度
            similarity = np.dot(input_embedding, self.current_topic['embedding']) / (
                np.linalg.norm(input_embedding) * np.linalg.norm(self.current_topic['embedding'])
            )
            
            if similarity < self.topic_transition_threshold:
                # 检测到主题转换
                self.current_topic = {
                    'topic': user_input[:50],
                    'embedding': input_embedding,
                    'start_time': time.time(),
                    'utterances': 1
                }
                self.topic_history.append(self.current_topic)
                
                # 限制历史记录长度
                if len(self.topic_history) > self.max_topic_history:
                    self.topic_history.pop(0)
            else:
                # 继续当前主题
                self.current_topic['utterances'] += 1
    
    def get_conversation_summary(self):
        """生成对话摘要"""
        if not self.topic_history:
            return "无对话历史"
        
        summary_parts = []
        for topic in self.topic_history:
            duration = time.time() - topic['start_time']
            summary_parts.append(f"- 讨论主题：{topic['topic']} (持续约{duration:.1f}秒，{topic['utterances']}轮对话)")
        
        return "对话历史摘要：\n" + "\n".join(summary_parts)

class NPCEmotionSystem:
    def __init__(self):
        # 基础情绪及其相互关系
        self.emotions = {
            "happy": {"opposite": "sad", "intensity": 0.5, "decay_rate": 0.02},
            "sad": {"opposite": "happy", "intensity": 0.0, "decay_rate": 0.015},
            "angry": {"opposite": "calm", "intensity": 0.0, "decay_rate": 0.03},
            "calm": {"opposite": "angry", "intensity": 0.5, "decay_rate": 0.01},
            "fearful": {"opposite": "confident", "intensity": 0.0, "decay_rate": 0.025},
            "confident": {"opposite": "fearful", "intensity": 0.3, "decay_rate": 0.01},
            "surprised": {"opposite": "expecting", "intensity": 0.0, "decay_rate": 0.04},
            "expecting": {"opposite": "surprised", "intensity": 0.2, "decay_rate": 0.01}
        }
        
        # 情绪触发器配置
        self.emotion_triggers = {
            "happy": ["表扬", "感谢", "成功", "奖励"],
            "sad": ["批评", "拒绝", "失败", "失去"],
            "angry": ["侮辱", "攻击", "背叛", "威胁"],
            "fearful": ["危险", "威胁", "怪物", "死亡"],
            "surprised": ["意外", "突然", "发现", "秘密"]
        }
    
    def update_emotions(self):
        """随着时间更新情绪强度（自然衰减）"""
        for emotion_name, emotion_data in self.emotions.items():
            emotion_data["intensity"] = max(0.0, emotion_data["intensity"] - emotion_data["decay_rate"])
    
    def trigger_emotion(self, trigger_text, intensity=0.3):
        """通过文本触发特定情绪"""
        for emotion, triggers in self.emotion_triggers.items():
            for trigger in triggers:
                if trigger.lower() in trigger_text.lower():
                    self._adjust_emotion(emotion, intensity)
    
    def _adjust_emotion(self, emotion, intensity_change):
        """调整特定情绪的强度，同时影响对立情绪"""
        if emotion in self.emotions:
            # 增加目标情绪
            self.emotions[emotion]["intensity"] = min(1.0, 
                                                      self.emotions[emotion]["intensity"] + intensity_change)
            
            # 减少对立情绪
            opposite_emotion = self.emotions[emotion]["opposite"]
            if opposite_emotion in self.emotions:
                self.emotions[opposite_emotion]["intensity"] = max(0.0, 
                                                                   self.emotions[opposite_emotion]["intensity"] - 
                                                                   intensity_change * 0.7)
    
    def get_dominant_emotion(self):
        """获取当前主导情绪"""
        return max(self.emotions.items(), key=lambda x: x[1]["intensity"])
    
    def get_emotion_effect_on_dialogue(self):
        """获取情绪对对话风格的影响描述"""
        dominant_emotion, data = self.get_dominant_emotion()
        
        emotion_effects = {
            "happy": "更加积极、友好，使用表情符号和感叹号",
            "sad": "更加消极、低沉，使用较少的词汇和较长的停顿",
            "angry": "更加直接、简短，可能包含感叹号和强调语气",
            "calm": "更加理性、平和，使用平衡的句式",
            "fearful": "更加谨慎、犹豫，可能包含不确定的表达",
            "confident": "更加坚定、肯定，使用直接的表达方式",
            "surprised": "更加简短、突然，包含惊讶的表达",
            "expecting": "更加期待、好奇，使用提问和引导性表达"
        }
        
        if data["intensity"] > 0.7:
            intensity_modifier = "非常明显地"
        elif data["intensity"] > 0.3:
            intensity_modifier = "明显地"
        else:
            intensity_modifier = "轻微地"
        
        return f"{dominant_emotion}情绪({data['intensity']:.2f})，{intensity_modifier}{emotion_effects.get(dominant_emotion, '')}"

class VoiceInteractionSystem:
    def __init__(self, asr_model="whisper-small", tts_model="tts-1"):
        # 导入语音识别和合成库
        try:
            import whisper
            from gtts import gTTS
            import pygame
            
            self.asr_available = True
            self.tts_available = True
            
            # 初始化语音识别模型
            self.asr_model = whisper.load_model(asr_model)
            
            # 初始化pygame用于音频播放
            pygame.mixer.init()
            
            # 语音参数配置
            self.language = "zh"
            self.speech_rate = 1.0
            self.volume = 1.0
            
        except ImportError:
            self.asr_available = False
            self.tts_available = False
            print("警告：语音处理库未安装，语音功能不可用")
    
    def transcribe_speech(self, audio_file):
        """将语音转换为文本"""
        if not self.asr_available:
            return "错误：语音识别功能不可用"
        
        try:
            result = self.asr_model.transcribe(audio_file, language=self.language)
            return result["text"]
        except Exception as e:
            print(f"语音识别错误: {e}")
            return "错误：无法识别语音"
    
    def text_to_speech(self, text, output_file="temp_speech.mp3"):
        """将文本转换为语音"""
        if not self.tts_available:
            return False
        
        try:
            tts = gTTS(text=text, lang=self.language, slow=False)
            tts.save(output_file)
            return True
        except Exception as e:
            print(f"语音合成错误: {e}")
            return False
    
    def play_speech(self, audio_file="temp_speech.mp3"):
        """播放语音文件"""
        if not self.tts_available:
            return False
        
        try:
            pygame.mixer.music.load(audio_file)
            pygame.mixer.music.set_volume(self.volume)
            pygame.mixer.music.play()
            
            # 等待播放完成
            while pygame.mixer.music.get_busy():
                pygame.time.Clock().tick(10)
            
            return True
        except Exception as e:
            print(f"音频播放错误: {e}")
            return False
    
    def speak_text(self, text):
        """完整的文本朗读流程"""
        success = self.text_to_speech(text)
        if success:
            return self.play_speech()
        return False

class PlayerExpressionRecognition:
    def __init__(self):
        # 导入视觉处理库
        try:
            import cv2
            import mediapipe as mp
            import numpy as np
            
            self.cv_available = True
            
            # 初始化面部和姿态估计模型
            self.mp_face_mesh = mp.solutions.face_mesh
            self.mp_pose = mp.solutions.pose
            
            self.face_mesh = self.mp_face_mesh.FaceMesh(min_detection_confidence=0.5, min_tracking_confidence=0.5)
            self.pose = self.mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5)
            
            # 表情分类器
            self.expressions = {
                "happy": 0,
                "sad": 0,
                "angry": 0,
                "surprised": 0,
                "neutral": 0
            }
            
            # 姿态分类器
            self.gestures = {
                "wave": False,
                "thumbs_up": False,
                "thumbs_down": False,
                "point": False,
                "cross_arms": False
            }
            
        except ImportError:
            self.cv_available = False
            print("警告：计算机视觉库未安装，表情识别功能不可用")
    
    def process_frame(self, frame):
        """处理单帧图像，识别表情和姿态"""
        if not self.cv_available:
            return {"expressions": None, "gestures": None}
        
        # 转换为RGB
        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        
        # 处理面部表情
        face_results = self.face_mesh.process(rgb_frame)
        if face_results.multi_face_landmarks:
            self._analyze_expression(face_results.multi_face_landmarks[0])
        
        # 处理身体姿态
        pose_results = self.pose.process(rgb_frame)
        if pose_results.pose_landmarks:
            self._analyze_gesture(pose_results.pose_landmarks)
        
        return {
            "expressions": self.expressions,
            "gestures": self.gestures
        }
    
    def _analyze_expression(self, face_landmarks):
        """分析面部表情"""
        # 这里是简化版本，实际应用中需要更复杂的算法
        # 重置表情计数器
        for expr in self.expressions:
            self.expressions[expr] = 0
        
        # 基于面部关键点计算表情（示例逻辑）
        # 在实际实现中，这应该使用更复杂的机器学习模型
        self.expressions["neutral"] = 1.0  # 默认为中性
    
    def _analyze_gesture(self, pose_landmarks):
        """分析身体姿态和手势"""
        # 重置手势状态
        for gesture in self.gestures:
            self.gestures[gesture] = False
        
        # 基于关键点位置分析手势（示例逻辑）
        # 在实际实现中，这需要精确的关键点坐标计算
    
    def get_dominant_expression(self):
        """获取主导表情"""
        if not self.cv_available:
            return "neutral"
        
        return max(self.expressions.items(), key=lambda x: x[1])[0]
    
    def has_active_gesture(self):
        """检查是否有活跃的手势"""
        if not self.cv_available:
            return False
        
        return any(self.gestures.values())
    
    def get_active_gestures(self):
        """获取所有活跃的手势"""
        if not self.cv_available:
            return []
        
        return [gesture for gesture, active in self.gestures.items() if active]

class EnvironmentAwareness:
    def __init__(self):
        self.current_location = "未知"
        self.time_of_day = "白天"  # 白天、黄昏、夜晚
        self.weather_conditions = "晴朗"
        self.surrounding_objects = []
        self.player_actions = []
        self.recent_events = []
    
    def update_environment(self, location=None, time_of_day=None, weather=None, objects=None):
        """更新环境信息"""
        if location is not None:
            self.current_location = location
        if time_of_day is not None:
            self.time_of_day = time_of_day
        if weather is not None:
            self.weather_conditions = weather
        if objects is not None:
            self.surrounding_objects = objects
    
    def record_player_action(self, action, timestamp=None):
        """记录玩家动作"""
        if timestamp is None:
            timestamp = time.time()
        
        self.player_actions.append({
            "action": action,
            "timestamp": timestamp
        })
        
        # 只保留最近的10个动作
        if len(self.player_actions) > 10:
            self.player_actions.pop(0)
    
    def record_event(self, event, importance=0.5, timestamp=None):
        """记录游戏事件"""
        if timestamp is None:
            timestamp = time.time()
        
        self.recent_events.append({
            "event": event,
            "importance": importance,
            "timestamp": timestamp
        })
        
        # 按重要性和时间排序，并保留最近的15个事件
        self.recent_events.sort(key=lambda x: (x["importance"], x["timestamp"]), reverse=True)
        self.recent_events = self.recent_events[:15]
    
    def get_relevant_context(self, conversation_topic=None):
        """获取与当前对话相关的环境上下文"""
        context = []
        
        # 添加基本环境信息
        context.append(f"位置：{self.current_location}")
        context.append(f"时间：{self.time_of_day}")
        context.append(f"天气：{self.weather_conditions}")
        
        # 添加周围重要物体
        if self.surrounding_objects:
            context.append(f"周围物体：{', '.join(self.surrounding_objects[:5])}")
        
        # 添加最近的玩家动作
        recent_actions = sorted(self.player_actions, key=lambda x: x["timestamp"], reverse=True)[:3]
        if recent_actions:
            actions_str = ", ".join([a["action"] for a in recent_actions])
            context.append(f"玩家最近动作：{actions_str}")
        
        # 添加重要事件
        important_events = [e for e in self.recent_events if e["importance"] >= 0.7][:3]
        if important_events:
            events_str = ", ".join([e["event"] for e in important_events])
            context.append(f"重要事件：{events_str}")
        
        return "\n".join(context)
    
    def generate_context_aware_prompt(self, base_prompt):
        """生成包含环境感知的提示"""
        environment_context = self.get_relevant_context()
        
        enhanced_prompt = f"""{base_prompt}

环境信息：
{environment_context}

请确保你的回应考虑当前的环境情况，与周围的环境、事件和玩家行为保持一致。"""
        
        return enhanced_prompt

class DialogueCacheSystem:
    def __init__(self, cache_size=100, ttl_seconds=3600):
        self.cache = {}
        self.cache_size = cache_size
        self.ttl_seconds = ttl_seconds  # 缓存过期时间
        self.access_count = {}  # 访问计数，用于LRU缓存替换
    
    def _get_key(self, prompt, model_params):
        """生成缓存键"""
        # 将提示和模型参数组合成唯一键
        key_parts = [prompt]
        
        # 添加所有相关的模型参数
        if "temperature" in model_params:
            key_parts.append(f"temp_{model_params['temperature']}")
        if "max_new_tokens" in model_params:
            key_parts.append(f"tokens_{model_params['max_new_tokens']}")
        if "top_p" in model_params:
            key_parts.append(f"top_p_{model_params['top_p']}")
        
        return "__".join(key_parts)
    
    def get_cached_response(self, prompt, model_params):
        """获取缓存的响应"""
        key = self._get_key(prompt, model_params)
        
        if key in self.cache:
            cached_data = self.cache[key]
            
            # 检查是否过期
            current_time = time.time()
            if current_time - cached_data["timestamp"] > self.ttl_seconds:
                # 缓存已过期，删除
                del self.cache[key]
                if key in self.access_count:
                    del self.access_count[key]
                return None
            
            # 更新访问计数
            self.access_count[key] = self.access_count.get(key, 0) + 1
            
            return cached_data["response"]
        
        return None
    
    def cache_response(self, prompt, model_params, response):
        """缓存响应"""
        key = self._get_key(prompt, model_params)
        
        # 检查缓存是否已满
        if len(self.cache) >= self.cache_size and key not in self.cache:
            # 移除访问次数最少的项
            if self.access_count:
                least_used = min(self.access_count.items(), key=lambda x: x[1])[0]
                if least_used in self.cache:
                    del self.cache[least_used]
                if least_used in self.access_count:
                    del self.access_count[least_used]
        
        # 存储响应
        self.cache[key] = {
            "response": response,
            "timestamp": time.time()
        }
        
        # 初始化访问计数
        self.access_count[key] = 1
    
    def clear_cache(self):
        """清空缓存"""
        self.cache = {}
        self.access_count = {}

class GameNPCDialogueSystem:
    def __init__(self, npc_name="神秘商人", model_name="distilgpt2"):
        # 初始化所有组件
        self.conversation_manager = ConversationManager(max_history_length=20)
        self.npc_memory = NPCMemorySystem(short_term_size=10, long_term_size=50)
        self.npc_emotions = NPCEmotionSystem()
        self.voice_system = VoiceInteractionSystem()
        self.expression_recog = PlayerExpressionRecognition()
        self.environment = EnvironmentAwareness()
        self.llm_deployer = OptimizedLLMDeployer(model_name=model_name)
        self.dialogue_cache = DialogueCacheSystem(cache_size=100)
        
        # NPC基本信息
        self.npc_name = npc_name
        self.npc_character = {
            "name": npc_name,
            "profile": "神秘商人",
            "personality": ["机智", "圆滑", "贪婪", "见多识广"],
            "background": "我曾环游世界，见过无数奇珍异宝。现在定居于此，只为与有缘人分享我的收藏。小心哦，我的商品可不便宜..."
        }
        
        # 初始化对话提示模板
        self.base_prompt_template = f"""
你是{npc_name}，一位{self.npc_character['profile']}。

性格特点：
{', '.join(self.npc_character['personality'])}

背景故事：
{self.npc_character['background']}

请以{self.npc_name}的身份回应玩家，保持角色一致性，语言要符合你的性格。
回答要简短自然，不要太长，符合游戏中的对话节奏。
        """
        
        # 加载语言模型
        self.llm_deployer.load_model()
        self.llm_deployer.optimize_for_latency()
        
        print(f"NPC对话系统已初始化，角色：{npc_name}")
    
    def process_player_input(self, player_input, is_voice=False):
        """处理玩家输入并生成NPC回应"""
        start_time = time.time()
        
        # 语音转文本（如果需要）
        if is_voice and self.voice_system.asr_available:
            # 在实际游戏中，这里应该有语音录制的逻辑
            player_text = "这是语音识别的结果示例"
        else:
            player_text = player_input
        
        # 更新NPC情绪
        self.npc_emotions.trigger_emotion(player_text)
        
        # 记录对话到NPC记忆
        self.npc_memory.add_memory(player_text, source="player", importance=0.5)
        
        # 构建完整的对话历史
        conversation_history = self.conversation_manager.get_conversation_history()
        
        # 生成带有环境感知的提示
        base_prompt = self.base_prompt_template
        enhanced_prompt = self.environment.generate_context_aware_prompt(base_prompt)
        
        # 添加情绪状态到提示
        emotion_info = self.npc_emotions.get_emotion_effect_on_dialogue()
        full_prompt = f"""{enhanced_prompt}

情绪状态：
{emotion_info}

对话历史：
{conversation_history}

玩家最新输入：{player_text}

请生成{npc_name}的回应："""
        
        # 尝试从缓存获取响应
        model_params = {"temperature": 0.7, "max_new_tokens": 50, "top_p": 0.9}
        cached_response = self.dialogue_cache.get_cached_response(full_prompt, model_params)
        
        if cached_response:
            npc_response = cached_response
            print("从缓存获取响应")
        else:
            # 生成新的响应
            npc_response = self.llm_deployer.generate_response(full_prompt, **model_params)
            
            # 缓存响应
            self.dialogue_cache.cache_response(full_prompt, model_params, npc_response)
        
        # 更新对话历史
        self.conversation_manager.add_message("player", player_text)
        self.conversation_manager.add_message("npc", npc_response)
        
        # 将回应添加到NPC记忆
        self.npc_memory.add_memory(npc_response, source="self", importance=0.3)
        
        # 更新情绪（时间衰减）
        self.npc_emotions.update_emotions()
        
        end_time = time.time()
        print(f"响应生成耗时：{(end_time - start_time)*1000:.2f}ms")
        
        return npc_response
    
    def speak_response(self, response_text):
        """通过语音合成播放NPC回应"""
        return self.voice_system.speak_text(response_text)
    
    def update_environment_info(self, location=None, time_of_day=None, weather=None, objects=None):
        """更新环境信息"""
        self.environment.update_environment(location, time_of_day, weather, objects)
    
    def record_game_event(self, event, importance=0.5):
        """记录游戏事件"""
        self.environment.record_event(event, importance)
    
    def process_player_expression(self, frame):
        """处理玩家表情和动作"""
        if not self.expression_recog.cv_available:
            return None
        
        result = self.expression_recog.process_frame(frame)
        
        # 如果检测到情绪，更新NPC情绪
        if result["expressions"]:
            dominant_expression = self.expression_recog.get_dominant_expression()
            expression_mapping = {
                "happy": "happy",
                "sad": "sad",
                "angry": "angry",
                "surprised": "surprised"
            }
            
            if dominant_expression in expression_mapping:
                self.npc_emotions._adjust_emotion(expression_mapping[dominant_expression], 0.2)
        
        # 如果检测到手势，记录为重要事件
        if result["gestures"] and self.expression_recog.has_active_gesture():
            active_gestures = self.expression_recog.get_active_gestures()
            self.record_game_event(f"玩家做出了{', '.join(active_gestures)}手势", importance=0.8)
        
        return result
    
    def get_diagnostics(self):
        """获取系统诊断信息"""
        return {
            "model_loaded": self.llm_deployer.is_loaded,
            "cache_size": len(self.dialogue_cache.cache),
            "memory_count": {
                "short_term": len(self.npc_memory.short_term_memories),
                "long_term": len(self.npc_memory.long_term_memories)
            },
            "current_emotion": self.npc_emotions.get_dominant_emotion(),
            "conversation_length": self.conversation_manager.get_conversation_length()
        }

# 游戏中的NPC对话系统使用示例
def game_demo():
    # 初始化NPC对话系统
    npc_system = GameNPCDialogueSystem(npc_name="神秘商人", model_name="distilgpt2")
    
    # 设置环境信息
    npc_system.update_environment_info(
        location="幽暗森林的边缘",
        time_of_day="黄昏",
        weather="薄雾",
        objects=["古老的摊位", "闪烁的魔法水晶", "奇异的植物"]
    )
    
    # 记录重要游戏事件
    npc_system.record_game_event("玩家击败了森林中的狼人", importance=0.9)
    
    print("=== 神秘商人对话演示 ===")
    print("商人：欢迎来到我的摊位，冒险者！我这里有许多奇珍异宝...")
    
    # 模拟玩家对话
    player_inputs = [
        "你好，我想买一些装备。",
        "这些水晶是做什么用的？",
        "你的价格太贵了！",
        "能给我讲讲这个森林的故事吗？"
    ]
    
    for player_text in player_inputs:
        print(f"\n玩家：{player_text}")
        
        # 处理玩家输入并获取NPC回应
        npc_response = npc_system.process_player_input(player_text)
        
        print(f"商人：{npc_response}")
        
        # 在实际游戏中，可以在这里播放NPC语音
        # npc_system.speak_response(npc_response)
    
    # 获取系统状态信息
    diagnostics = npc_system.get_diagnostics()
    print("\n=== 系统状态 ===")
    print(f"模型加载状态: {diagnostics['model_loaded']}")
    print(f"缓存大小: {diagnostics['cache_size']}")
    print(f"记忆数量: 短期 {diagnostics['memory_count']['short_term']}, 长期 {diagnostics['memory_count']['long_term']}")
    print(f"当前情绪: {diagnostics['current_emotion'][0]} ({diagnostics['current_emotion'][1]['intensity']:.2f})")
    print(f"对话长度: {diagnostics['conversation_length']}")

# 运行演示
if __name__ == "__main__":
    game_demo()