Update app.py

app.py

@@ -192,104 +192,132 @@ class SpyAgent(BasicAgent):
     def detect_spy_word(self):
         """分析历史发言，尝试识别卧底词（平民使用）"""
         # 如果自己是卧底或者没有足够发言，跳过
-        if self.identity_identify() <= 0 or self.get_prior_speaker_count() < 3:
+        if self.identity_identify() <= 0 or self.get_prior_speaker_count() < 2:  # 改为2个就可以尝试推测
             return None
-            
+                
         speak_history = self.memory.load_variable('speak_history')
         if not speak_history:
             return None
         
-        # 构建推理提示
+        # 获取自己的词和可能的平民词
+        my_word = self.memory.load_variable("word")
+        
+        # 构建更直接的推理提示
         prompt = []
-        prompt.append('你是《谁是卧底》游戏的平民玩家，需要找出谁是卧底。')
-        prompt.append(f'你拿到的平民词是"{self.memory.load_variable("word")}"。')
+        prompt.append(f'你正在玩《谁是卧底》游戏，你拿到的词是"{my_word}"，你是平民。')
+        prompt.append('作为平民，你需要找出谁可能是卧底以及他们的卧底词是什么。')
         prompt.append('游戏规则：6名玩家中，5人拿到相同的平民词，1人拿到与平民词相关但不同的卧底词。')
-        prompt.append('你需要分析其他玩家的发言，找出谁可能是卧底，以及他们可能拿到的卧底词是什么。')
-        prompt.append('请仔细分析以下玩家发言，寻找与平民词描述不一致的地方：\n')
+        prompt.append(f'请分析以下玩家发言，判断谁可能拿到了与"{my_word}"相近但不同的词：\n')
         
-        # 添加玩家发言
+        # 添加玩家发言，并标记轮次以便分析
         for name, speaks in speak_history.items():
             if name != self.memory.load_variable('name'):
-                for speak in speaks:
-                    prompt.append(f"{name}: {speak}\n")
+                for i, speak in enumerate(speaks):
+                    prompt.append(f"[轮次{i+1}] {name}: {speak}\n")
         
-        prompt.append('\n你需要：')
-        prompt.append('1. 分析每个玩家的发言是否与平民词一致')
-        prompt.append('2. 找出可能的不一致描述')
-        prompt.append('3. 推测可能的卧底词')
-        prompt.append('\n请直接回答你推测的卧底词(单词)，不要有任何其他内容。如果无法确定，只回答"未知"。')
+        prompt.append('\n请先判断是否有玩家的发言与你的词不符合:')
+        prompt.append('1. 列出可疑的描述特征')
+        prompt.append('2. 考虑与你的词"' + my_word + '"最相近但有关键区别的可能卧底词')
+        prompt.append('3. 最后直接回答你认为的卧底词(单词或短词)')
+        prompt.append('\n如果所有玩家都在描述同一个词，且你确定无法判断卧底词，只回答"未知"。')
         
         spy_word = self.llm_caller(''.join(prompt))
         logger.info(f"卧底词推理原始返回: '{spy_word}'")
         
-        # 处理返回结果（与处理平民词类似的清理逻辑）
+        # 处理返回结果
         if spy_word:
+            # 先检查是否包含长分析，提取最后一段或冒号后内容
+            if len(spy_word) > 50 and "\n" in spy_word:
+                # 尝试从最后几行提取答案
+                lines = spy_word.strip().split("\n")
+                for line in reversed(lines):
+                    if len(line.strip()) < 30 and line.strip() and not line.strip().startswith("1.") and not line.strip().startswith("2."):
+                        spy_word = line.strip()
+                        break
+            
+            # 清理格式符号
             cleaned_word = spy_word.strip().strip('"\'[]()（）""「」『』').strip()
             
-            # 验证结果是否有效
-            reject_words = ["未知", "不清楚", "无法确定"]
-            if (not any(reject in cleaned_word for reject in reject_words) and 
-                len(cleaned_word) < 20 and cleaned_word != self.memory.load_variable("word")):
+            # 处理冒号
+            if ":" in cleaned_word or "：" in cleaned_word:
+                parts = re.split(r'[:：]', cleaned_word)
+                cleaned_word = parts[-1].strip()
+            
+            # 扩大拒绝词列表
+            reject_patterns = ["未知", "不清楚", "无法确定", "不确定", "无法判断", "无法推理", 
+                            "无法识别", "难以确定", "没有足够", "不能确定"]
+                            
+            # 更灵活的验证条件
+            if (not any(pattern in cleaned_word.lower() for pattern in reject_patterns) and
+                len(cleaned_word) < 25 and len(cleaned_word) > 1 and
+                cleaned_word != my_word):
                 
                 logger.info(f"成功推理出卧底词: '{cleaned_word}'")
                 return cleaned_word
         
         return None
     def detect_civilian_word(self):
-        """分析历史发言，尝试识别平民词"""
+        """分析历史发言，尝试识别平民词（卧底使用）"""
         speak_history = self.memory.load_variable('speak_history')
         if not speak_history:
             return None
         
-        # 构建推理提示
+        
+        # 构建更清晰的提示
         prompt = []
-        prompt.append('你是《谁是卧底》游戏的评审，需要推理出玩家们描述的词语。')
-        prompt.append(f'已知一名玩家的词是"{self.memory.load_variable("word")}"，有理由相信大多数其他玩家在描述另一个相关但不同的词。')
-        prompt.append('《谁是卧底》游戏规则：5名玩家拿到相同的平民词，1名玩家拿到不同的卧底词。')
-        prompt.append('请仔细分析以下玩家发言，推理出大多数玩家可能在描述的词：\n')
-    
+        prompt.append('你是《谁是卧底》游戏中的卧底，需要推测出大多数玩家拿到的词语。')
+        prompt.append(f'你拿到的卧底词是"{self.memory.load_variable("word")}"。')
+        prompt.append('游戏规则：6名玩家中，5人拿到相同的平民词，1人（你）拿到不同的卧底词。')
+        prompt.append('请分析以下玩家发言，找出大多数玩家最可能在描述的共同词语：\n')
+
+        # 添加玩家发言
         for name, speaks in speak_history.items():
             if name != self.memory.load_variable('name'):
-                for speak in speaks:
-                    prompt.append(f"{name}: {speak}\n")
+                for i, speak in enumerate(speaks):
+                    if speak.strip():
+                        prompt.append(f"[轮次{i+1}] {name}: {speak}\n")
+        
+        prompt.append('\n请分析步骤：')
+        prompt.append('1. 找出发言中的共同主题和特征')
+        prompt.append('2. 考虑这些特征最可能对应的词语')
+        prompt.append('3. 考虑这个词与你的词"'+self.memory.load_variable("word")+'"的关系')
+        prompt.append('\n请直接输出你认为大多数玩家在描述的词语(单个词)。不要输出分析过程。')
         
-        prompt.append('\n推理步骤：')
-        prompt.append('1. 分析每个玩家发言中描述的特征')
-        prompt.append('2. 找出发言中的共同特征')
-        prompt.append('3. 根据这些特征，推测最可能的词语')
-        prompt.append('4. 考虑这个词与已知词"'+self.memory.load_variable("word")+'"的关系，两者应该相似但有明显区别')
-        prompt.append('\n请直接回答你推理出的词语(单词)。如果实在无法推理，只回答"未知"。')
-       # 调用LLM进行推理
         civilian_word = self.llm_caller(''.join(prompt))
         logger.info(f"平民词推理原始返回: '{civilian_word}'")
         
-        # 处理返回结果
+        # 增强的结果处理
         if civilian_word:
-            # 清理结果，移除常见的格式标记和说明文本
-            cleaned_word = civilian_word
+            # 如果是长回答，尝试提取最后一句或最简短的句子
+            if len(civilian_word) > 30:
+                if "\n" in civilian_word:
+                    lines = [line for line in civilian_word.strip().split("\n") if line.strip()]
+                    for line in reversed(lines):
+                        if 1 < len(line.strip()) < 30:
+                            civilian_word = line.strip()
+                            break
+                # 如果包含句号，尝试提取最后一句
+                elif "。" in civilian_word:
+                    sentences = civilian_word.split("。")
+                    for sentence in reversed(sentences):
+                        if 1 < len(sentence.strip()) < 30:
+                            civilian_word = sentence.strip()
+                            break
             
-            # 如果包含多行，尝试提取最后一行作为答案
-            if "\n" in cleaned_word:
-                lines = cleaned_word.strip().split("\n")
-                for line in reversed(lines):
-                    if line.strip() and len(line.strip()) < 30:  # 找到最后一个非空且较短的行
-                        cleaned_word = line.strip()
-                        break
-            
-            # 清理常见的格式符号和修饰语
-            cleaned_word = cleaned_word.strip().strip('"\'[]()（）""「」『』').strip()
+            # 清理格式标记
+            cleaned_word = civilian_word.strip().strip('"\'[]()（）""「」『』').strip()
             
-            # 如果结果包含冒号，取冒号后面的部分
+            # 处理冒号
             if ":" in cleaned_word or "：" in cleaned_word:
                 parts = re.split(r'[:：]', cleaned_word)
                 cleaned_word = parts[-1].strip()
-                
+            
             logger.info(f"清理后的平民词推理结果: '{cleaned_word}'")
             
-            # 验证结果是否有效
-            reject_words = ["未知", "不清楚", "无法确定", "不确定", "无法判断", "无法推理"]
-            if (not any(reject in cleaned_word for reject in reject_words) and 
-                len(cleaned_word) < 20 and len(cleaned_word) > 0 and 
+            # 更宽松的验证条件
+            reject_words = ["未知", "不清楚", "无法", "不确定", "难以"]
+            if (not any(reject in cleaned_word.lower() for reject in reject_words) and 
+                len(cleaned_word) > 1 and len(cleaned_word) < 25 and 
                 cleaned_word != self.memory.load_variable("word")):
                 
                 logger.info(f"成功推理出平民词: '{cleaned_word}'")