Update app.py

app.py

@@ -51,6 +51,8 @@ class SpyAgent(BasicAgent):
         self.memory.clear()
         self.memory.set_variable("name", req.message.strip())
         self.memory.set_variable('history', [])
+        self.memory.set_variable('spy_player', "")  # 可能的卧底玩家
+        self.memory.set_variable('spy_analysis', "")  # 卧底分析详情
         self.memory.set_variable('sim_word', "")  # 空字符串而非空列表
         self.memory.set_variable('spy_word', "")  # 新增：可能的卧底词
         self.memory.set_variable("alive_agents", set([req.message.strip()]))
@@ -190,70 +192,73 @@ class SpyAgent(BasicAgent):
                 if name != self.memory.load_variable("name") 
                 and name in self.memory.load_variable('alive_agents')])
     def detect_spy_word(self):
-        """分析历史发言，尝试识别卧底词（平民使用）"""
-        # 如果自己是卧底或者没有足够发言，跳过
-        if self.identity_identify() <= 0 or self.get_prior_speaker_count() < 2:  # 改为2个就可以尝试推测
+        """分析历史发言，尝试识别卧底词和卧底玩家（平民使用）"""
+        if self.identity_identify() <= 0 or self.get_prior_speaker_count() < 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(f'你正在玩《谁是卧底》游戏，你拿到的词是"{my_word}"，你是平民。')
         prompt.append('作为平民，你需要找出谁可能是卧底以及他们的卧底词是什么。')
         prompt.append('游戏规则：6名玩家中，5人拿到相同的平民词，1人拿到与平民词相关但不同的卧底词。')
         prompt.append(f'请分析以下玩家发言，判断谁可能拿到了与"{my_word}"相近但不同的词：\n')
         
-        # 添加玩家发言，并标记轮次以便分析
+        # 添加玩家发言
         for name, speaks in speak_history.items():
             if name != self.memory.load_variable('name'):
                 for i, speak in enumerate(speaks):
                     prompt.append(f"[轮次{i+1}] {name}: {speak}\n")
         
-        prompt.append('\n请先判断是否有玩家的发言与你的词不符合:')
-        prompt.append('1. 列出可疑的描述特征')
-        prompt.append('2. 考虑与你的词"' + my_word + '"最相近但有关键区别的可能卧底词')
-        prompt.append('3. 最后直接回答你认为的卧底词(单词或短词)')
-        prompt.append('\n如果所有玩家都在描述同一个词，且你确定无法判断卧底词，只回答"未知"。')
+        prompt.append('\n请按以下格式回答：')
+        prompt.append('可疑玩家：[玩家名字]')
+        prompt.append('可疑理由：[简短说明为什么这个玩家可疑]')
+        prompt.append('卧底词：[你推测的卧底词]')
+        prompt.append('\n如果所有玩家都在描述同一个词，且你无法判断，则回答：')
+        prompt.append('可疑玩家：未知')
+        prompt.append('可疑理由：信息不足')
+        prompt.append('卧底词：未知')
+        
+        spy_detection = self.llm_caller(''.join(prompt))
+        logger.info(f"卧底识别原始返回: '{spy_detection}'")
         
-        spy_word = self.llm_caller(''.join(prompt))
-        logger.info(f"卧底词推理原始返回: '{spy_word}'")
+        # 存储完整分析结果
+        self.memory.set_variable('spy_analysis', spy_detection)
         
-        # 处理返回结果
-        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()
+        # 提取关键信息
+        spy_name = None
+        spy_word = None
+        
+        # 提取可疑玩家
+        name_match = re.search(r'可疑玩家[：:]\s*(.+?)(?:\n|$)', spy_detection)
+        if name_match:
+            suspect = name_match.group(1).strip()
+            if not any(word in suspect.lower() for word in ["未知", "不确定", "无法判断"]):
+                for player in speak_history.keys():
+                    if player in suspect and player != self.memory.load_variable('name'):
+                        spy_name = player
+                        self.memory.set_variable('spy_player', player)
+                        logger.info(f"成功识别可疑卧底: '{player}'")
                         break
+        
+        # 提取卧底词
+        word_match = re.search(r'卧底词[：:]\s*(.+?)(?:\n|$)', spy_detection)
+        if word_match:
+            word = word_match.group(1).strip()
+            cleaned_word = word.strip().strip('"\'[]()（）""「」『』').strip()
             
-            # 清理格式符号
-            cleaned_word = spy_word.strip().strip('"\'[]()（）""「」『』').strip()
-            
-            # 处理冒号
-            if ":" in cleaned_word or "：" in cleaned_word:
-                parts = re.split(r'[:：]', cleaned_word)
-                cleaned_word = parts[-1].strip()
-            
-            # 扩大拒绝词列表
-            reject_patterns = ["未知", "不清楚", "无法确定", "不确定", "无法判断", "无法推理", 
-                            "无法识别", "难以确定", "没有足够", "不能确定"]
-                            
-            # 更灵活的验证条件
+            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
+                spy_word = cleaned_word
+                logger.info(f"成功推理出卧底词: '{spy_word}'")
+                return spy_word
         
         return None
     def detect_civilian_word(self):
@@ -368,7 +373,13 @@ class SpyAgent(BasicAgent):
                 # '2)你可以先根据自己拿到的词，以及其他玩家的发言跟自己的词是不是相关，来判断自己是多数的平民、还是少数的卧底；')
                 self.memory.append_history(
                     '2)尽可能简短、模糊描述自己的词汇，可以使用比喻等手法，隐晦模糊地描述自己的词汇。避免暴露太多特征，仅使用一小句；示例：【正方形】-这是一种形状，在生活中很常见')
-                self.memory.append_history('3)你应该根据自己拿到的词，通过猜测可能的对手词是什么，来印证自己的猜测；在上一阶段推测出的卧底词是"{}"。'.format(self.memory.load_variable('spy_word')))
+                self.memory.append_history('3)你应该根据自己拿到的词，通过猜测可能的对手词是什么')
+                spy_player = self.memory.load_variable('spy_player')
+                spy_analysis = self.memory.load_variable('spy_analysis')
+                if spy_player and spy_player in choices:
+                    self.memory.append_history(f'3)通过分析，你认为"{spy_player}"最可能是卧底，推测出的卧底词是"{self.memory.load_variable("spy_word")}"。')
+                else:
+                    self.memory.append_history(f'3)在上一阶段，你推测出的卧底词是"{self.memory.load_variable("spy_word")}"。')
                 self.memory.append_history(
                     '4)如果你明确判断出自己是卧底，那你完全可以直接描述平民词来彻底伪装自己；否则，你应该模糊描述词汇，避免暴露太多特征；')
                 self.memory.append_history(
@@ -583,16 +594,22 @@ class SpyAgent(BasicAgent):
         )
 
         result = completion.choices[0].message.content.lstrip('\n\t\r')
+        logger.info("vote analysis result: {}".format(result))
 
-        logger.info("analysis result: {}".format(result))
+        # 保存投票分析结果
+        self.memory.set_variable('vote_analysis', result)
 
+        # 提取具体的投票对象
         session_data = [{'role': 'assistant', 'content': result}]
-        name_extract_prompt = '好的，请从你上述分析中，明确最终需要投票玩家的名字。请直接输出名字，不要输出任何其他内容。'
-        session_data.append({'role': 'user', 'content': name_extract_prompt})
-
+        name_extract_prompt = '请从你的分析中，明确指出你最终决定投票的玩家名字。请只回答玩家名字，不要有任何额外内容。'
+        
         completion = client.chat.completions.create(
             model=self.model_name,
-            messages=session_data
+            messages=[
+                {'role': 'user', 'content': prompt},
+                {'role': 'assistant', 'content': result},
+                {'role': 'user', 'content': name_extract_prompt}
+            ]
         )
 
         return completion.choices[0].message.content.lstrip('\n\t\r')