NPC 수정 진행 및 1차 정상 작동 확인

npc_social_network/models/llm_helper.py

@@ -4,6 +4,8 @@ from npc_social_network.npc.emotion_config import EMOTION_LIST
 from npc_social_network.models.gemini_setup import load_gemini
 from npc_social_network.npc.npc_memory import Memory
 from typing import List
+import json
+import re
 
 # Gemini 모델 초기화
 gemini_model = load_gemini()
@@ -55,4 +57,33 @@ def summarize_memories(memories: List[Memory]) -> str:
 
     # LLM 호출 함수를 사용하여 요약 요청
     summary = query_llm_with_prompt(prompt)
-    return summary
+    return summary
+
+def analyze_gossip(gossip_content: str) -> dict:
+    """LLM을 이용해 소문을 분석하고, 관련 인물과 긍/부정을 JSON으로 반환합니다."""
+    prompt="""
+# 지시사항
+다음 소문 내용에서 핵심 인물 2명과, 그들 사이의 상호작용이 긍정적인지, 부정적인지, 중립적인지 분석해줘.
+결과를 반드시 아래 JSON 형식으로만 응답해줘, 다른 설명은 붙이지 마.
+
+# 소문 내용
+"{gossip_content}"
+
+# 분석 결과 (JSON 형식)
+{{
+    "person1": "첫 번째 인물 이름",
+    "person2": "두 번째 인물 이름",
+    "sentiment": "positive or negative or neutral",
+    "reason": "한 문장으로 요약한 이유"
+}}
+"""
+    try:
+        response_text = query_llm_with_prompt(prompt)
+        # LLM 응답에서 JSON 부분만 추출
+        json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+        if json_match:
+            return json.loads(json_match.group())
+        return {}
+    except (json.JSONDecodeError, Exception) as e:
+        print(f"소문 분석 중 오류 발생: {e}")
+        return {}

npc_social_network/models/llm_prompt_builder.py

@@ -15,7 +15,8 @@ def build_npc_prompt(npc:"NPC", user_input: str, matched_memories: List[Memory],
     - SocialProfile의 관꼐 요약을 프롬프트에 포함하도록 수정
     """
     # 대화 상대방의 이름을 동적으로 설정
-    interlocutor_name = target_npc.name if target_npc else "플레이어"
+    interlocutor_name = target_npc.name if target_npc else "player"
+    interlocutor_korean_name = target_npc.korean_name if target_npc else "플레이어"
 
     # 감정 상태 요약
     emotion_summary = npc.summarize_emotional_state()
@@ -24,6 +25,15 @@ def build_npc_prompt(npc:"NPC", user_input: str, matched_memories: List[Memory],
     # 관계 요약
     relationship_description = npc.get_relationship_description(interlocutor_name)
 
+    # 평판 정보
+    reputation_info = ""
+    if target_npc:
+        reputation_score = npc.reputation.get(target_npc.name, 0)
+        if reputation_score > 5:
+            reputation_info = f"- '{target_npc.korean_name}'에 대한 평판: 신뢰할 만한 사람 같다. (평판 점수: {reputation_score})"
+        elif reputation_score < -5:
+            reputation_info = f"- '{target_npc.korean_name}'에 대한 평판: 그다지 좋은 소문을 듣지 못했다. (평판 점수: {reputation_score})"
+
     # 기억 유무에 따른 동적 지침 생성
     if matched_memories:
         memory_section_title = "# 연관된 기억"
@@ -65,15 +75,16 @@ def build_npc_prompt(npc:"NPC", user_input: str, matched_memories: List[Memory],
         {instruction}
 
         # 나의 프로필
-        - 이름: {npc.name}
+        - 이름: {npc.korean_name}
         - 직업: {npc.job}
-        - 현재 대화 상대: {interlocutor_name}
+        - 현재 대화 상대: {interlocutor_korean_name}
         - 현재 시간대: {time_context}
 
         # 나의 내면 상태
         - 현재 감정: {emotion_summary}
         - 성격: {personality_summary}
-        - {interlocutor_name}와(과)의 관계: {relationship_description}
+        - {interlocutor_korean_name}와(과)의 관계: {relationship_description}
+        - {reputation_info}
 
         {symbolic_section}
 
@@ -81,7 +92,7 @@ def build_npc_prompt(npc:"NPC", user_input: str, matched_memories: List[Memory],
         {memory_section}
 
         # 대화 로그
-        {interlocutor_name}: "{user_input}"
-        {npc.name}:
+        {interlocutor_korean_name}: "{user_input}"
+        {npc.korean_name}:
 """
     return prompt

npc_social_network/npc/npc_base.py

@@ -10,10 +10,13 @@ from .emotion_config import EMOTION_LIST, EMOTION_CATEGORY_MAP, EMOTION_DECAY_RA
 from .emotion_config import POSITIVE_RELATION_EMOTIONS, NEGATIVE_RELATION_EMOTIONS, COGNITIVE_RELATION_EMOTIONS
 from .personality_config import AGE_PROFILE, PERSONALITY_PROFILE
 from .npc_relationship import RelationshipManager
-from ..models.llm_helper import query_llm_with_prompt, query_llm_for_emotion, summarize_memories
+from ..models.llm_helper import query_llm_with_prompt, query_llm_for_emotion, summarize_memories, analyze_gossip
 from ..models.llm_prompt_builder import build_npc_prompt
 from .npc_memory_embedder import search_similar_memories
 from .npc_planner import PlannerManager
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from .npc_manager import NPCManager
 
 
 # Personality 데이터를 관리하고 요약 기능을 제공하는 클래스 정의
@@ -73,8 +76,10 @@ class NPC:
     NPC 클래스
     NPC에 대한 기본 정보를 객체화
     """
-    def __init__(self, name: str, job: str, personality: Optional[dict]=None):
+    def __init__(self, name: str, korean_name: str, job: str,
+                 personality: Optional[dict]=None):
         self.name = name
+        self.korean_name = korean_name
         self.job = job
 
         # npc 기억
@@ -83,7 +88,7 @@ class NPC:
         # 감정 상태 등 감정 관리자 초기화
         self.personality = PersonalityManager(personality)
         self.relationships = RelationshipManager(self)
-        self.relation = {}  # 다른 NPC에 대한 평판 저장
+        self.reputation = {}  # 다른 NPC에 대한 평판 저장
         self.emotion = EmotionManager(EMOTION_DECAY_RATE, self.personality)
         # 행동 관리자
         self.behavior = BehaviorManager()
@@ -157,8 +162,9 @@ class NPC:
                 self.update_emotion(emotion, strength=2.0)
 
             # 5. 상호작용 기억 저장
-            interlocutor_name = target_npc.name if target_npc else "플레이어"
-            memory_content = f"[{interlocutor_name}의 말] '{user_input}' → [나의 응답] '{npc_reply}'"
+            interlocutor_name = target_npc.name if target_npc else "player"
+            interlocutor_korean_name = target_npc.korean_name if target_npc else "플레이어"
+            memory_content = f"[{interlocutor_korean_name}의 말] '{user_input}' → [나의 응답] '{npc_reply}'"
             memory = self.remember(content=memory_content, importance=7, emotion=emotion, context_tags=[time_context])
 
             # 6. 관계 상태 업데이트
@@ -209,7 +215,7 @@ class NPC:
 
     def remember(self, content: str, importance: int = 5, emotion: str = None,
                  strength: float = 1.0, memory_type:str = "Event",
-                 context_tags: Optional[List[str]]=None) -> Memory:
+                 context_tags: Optional[List[str]]=None, npc_manager: "NPCManager" = None) -> Memory:
         """
         NPC가 새로운 기억을 저장하고 감정 상태에 반영
         """
@@ -224,22 +230,12 @@ class NPC:
         if emotion and emotion in EMOTION_LIST:
             self.update_emotion(emotion, strength)  # strength = importance / 5.0으로도 가능
         # 만약 기억이 '소문'이라면, 평판을 업데이트
-        if memory_type == "Gossip":
+        if memory_type == "Gossip" and npc_manager:
             # (간단한 예시: LLM으로 소문의 대상과 긍/부정을 파악해야 더 정확함)
             # 긍정 소문 예시: "밥이 찰리를 도왔다"
             # 부정 소문 예시: "엘린이 앨리스와 다퉜다"
-            
-            # 임시로 키워드 기반 평판 변경
-            if "도왔다" in content or "칭찬했다" in content:
-                # 긍정적 소문의 대상을 찾아 평판 +1
-                # ... (대상 파싱 로직) ...
-                pass
-            elif "다퉜다" in content or "비난했다" in content:
-                # 부정적 소문의 대상들을 찾아 평판 -1
-                # ... (대상 파싱 로직) ...
-                # 예시: self.update_reputation("엘린", -1)
-                #       self.update_reputation("앨리스", -1)
-                pass
+            self.process_gossip_and_update_reputation(memory, npc_manager)
+
         return memory   # 생성된 기억 객체 반환
 
     def update_emotion(self, emotion:str, strength: float = 1.0):
@@ -406,13 +402,13 @@ class NPC:
         summary = summarize_memories(memories)
         if "[LLM Error]" in summary: return
         self.remember(
-            Memory(content=f"[요약된 기억] {summary}",
-                   importance=9,
-                   emotion=self.emotion.get_dominant_emotion(),
-                   memory_type="Summary")
+            content=f"[요약된 기억] {summary}",
+            importance=9,
+            emotion=self.emotion.get_dominant_emotion(),
+            memory_type="Summary"
         )
 
-    def update_autonomous_behavior(self, time_context: str):
+    def update_autonomous_behavior(self, time_context: str, npc_manager, add_log):
         """
         NPC가 스스로 판단하여 행동을 결정하는 자율 행동 로직
         주기적으로 호출되어 목표 설정, 계획 실행 등을 담당.
@@ -438,18 +434,18 @@ class NPC:
                 gossip_to_spread = random.choice(gossip_memories)
                 
                 # 아직 대화한 적 없는 NPC를 타겟으로 선정
-                potential_targets = [npc for npc in npc_manager.all() if npc.name != self.name] # npc_manager에 접근 가능해야 함
+                potential_targets = [npc for npc in npc_manager.all() if npc.name != self.name]
                 if potential_targets:
                     target_npc = random.choice(potential_targets)
                     
                     # LLM을 활용하여 소문을 퍼뜨리는 대화 생성
                     gossip_dialogue = self.generate_dialogue(
-                        user_input=f"'{target_npc.name}'에게 '{gossip_to_spread.content}'에 대해 넌지시 이야기한다.",
+                        user_input=f"'{target_npc.korean_name}'에게 '{gossip_to_spread.content}'에 대해 넌지시 이야기한다.",
                         time_context=time_context,
                         target_npc=target_npc
                     )
                     
-                    add_log(f"[소문 전파] {self.name} -> {target_npc.name}: {gossip_dialogue}")
+                    add_log(f"[소문 전파] {self.korean_name} -> {target_npc.korean_name}: {gossip_dialogue}")
                     gossip_to_spread.is_shared = True # 소문이 전파되었음을 표시 (중복 전파 방지)
 
             # 일정 확률로 새로운 목표를 생성 (매번 생성하지 않도록)
@@ -475,7 +471,7 @@ class NPC:
 
         prompt = f"""
             # 지시사항
-            나는 '{self.name}'입니다. 다음은 나의 인생 기억 중 일부입니다.
+            나는 '{self.korean_name}'입니다. 다음은 나의 인생 기억 중 일부입니다.
             이 기억들을 바탕으로, "{theme}"이라는 주제에 대해 당신의 삶을 대표하는 상징적인 의미나 깨달음을 한 문장의 독백으로 생성해주세요.
 
             # 나의 기억들
@@ -494,12 +490,49 @@ class NPC:
                 emotion = "rumination",  # 반추, 성찰과 관련된 감정
                 memory_type="Symbolic",
             )
-            print(f"[{self.name}]의 새로운 깨달음: {symbolic_thought}")
+            print(f"[{self.korean_name}]의 새로운 깨달음: {symbolic_thought}")
 
-    def update_reputation(self, target_name: str, score_change: int):
+    def update_reputation(self, target_name: str, score_change: int, npc_manager: "NPCManager"):
         """특정 대상에 대한 평판 점수를 변경"""
         if self.name == target_name: return  # 자기 자신에 대한 평판x (자기 자신의 평판에 대한 내용도 성격 형성에 중요할 수 있지 않나?)
 
         current_score = self.reputation.get(target_name, 0)
         self.reputation[target_name] = current_score + score_change
-        print(f"[{self.name}]의 {target_name}에 대한 평판: {self.reputation[target_name]} ({score_change:+.0f})")
+
+        target_npc = npc_manager.get_npc_by_name(target_name)
+        target_korean_name = target_npc.korean_name if target_npc else target_name
+
+        print(f"[{self.korean_name}]의 {target_korean_name}에 대한 평판: {self.reputation[target_name]} ({score_change:+.0f})")
+
+
+    def process_gossip_and_update_reputation(self, gossip_memory: Memory, npc_manager: "NPCManager"):
+        """LLM을 이용해 소문을 분석하고 관련 인물들의 평판을 업데이트"""
+
+        analysis = analyze_gossip(gossip_memory.content)
+        if not analysis:
+            return
+        
+        person1_korean_name = analysis.get("person1")
+        person2_korean_name = analysis.get("person2")
+        sentiment = analysis.get("sentiment")
+
+        if not all([person1_korean_name, person2_korean_name, sentiment]):
+            return
+        
+        score_change = 0
+
+        if sentiment == "positive":
+            score_change = 2
+        elif sentiment == "negative":
+            score_change = -2
+
+        if score_change != 0:
+            # LLM이 반환한 한글 이름으로 NPC 객체를 찾아 영어 ID를 가져온다.
+            p1_npc = npc_manager.get_npc_by_korean_name(person1_korean_name)
+            p2_npc = npc_manager.get_npc_by_korean_name(person2_korean_name)
+
+            # 소문의 대상이 된 두 사람에 대한 나의 평판을 변경
+            if p1_npc:
+                self.update_reputation(p1_npc.name, score_change, npc_manager)
+            if p2_npc:
+                self.update_reputation(p2_npc.name, score_change, npc_manager)

npc_social_network/npc/npc_manager.py

@@ -5,24 +5,37 @@ from typing import TYPE_CHECKING, List, Optional
 if TYPE_CHECKING:
     from .npc_base import NPC
 
+def get_korean_postposition(name, first_char, second_char):
+    """이름의 마지막 글자 받침 유무에 따라 올바른 조사를 반환"""
+    if (ord(name[-1]) - 0xAC00) % 28 > 0:
+        return first_char
+    else:
+        return second_char
+
 class NPCManager:
     """모든 NPC를 관리하는 중앙 관리자"""
     def __init__(self):
         self.npcs: list['NPC'] = []
         self.npc_dict: dict[str, 'NPC'] = {}
+        self.korean_name_to_npc: dict[str, 'NPC'] = {}  # 한글 이름 검색용 딕셔너리
 
     def add_npc(self, npc: 'NPC'):
         """NPC를 매니저에 추가합니다."""
         if npc.name not in self.npc_dict:
             self.npcs.append(npc)
             self.npc_dict[npc.name] = npc
+            self.korean_name_to_npc[npc.korean_name] = npc
 
     def get_npc_by_name(self, name: str) -> Optional['NPC']:
         """
-        NPC 이름을 통해서 NPC의 정보를 반환
+        NPC 영어 ID를 통해서 NPC의 정보를 반환
         """
         return self.npc_dict.get(name)
     
+    def get_npc_by_korean_name(self, korean_name: str) -> Optional['NPC']:
+        """NPC 한글 이름을 통해서 NPC의 정보를 반환"""
+        return self.korean_name_to_npc.get(korean_name)
+    
     def get_random_npc(self, exclude: Optional['NPC']=None) -> Optional['NPC']:
         """
         특정 NPC를 제외하고 랜덤한 NPC를 선택
@@ -55,27 +68,30 @@ class NPCManager:
         if not initiator or not target:
             return
         
-        print(f"\n---[NPC 상호작용 이벤트]---\n{initiator.name}이(가) {target.name}에게 상호작용을 시도합니다.")
+        initiator_postposition = get_korean_postposition(initiator.korean_name, "이", "가")
+        target_postposition = get_korean_postposition(target.korean_name, "에게", "에게")
+        
+        print(f"\n---[NPC 상호작용 이벤트]---\n{initiator.korean_name}{initiator_postposition} {target.korean_name}{target_postposition} 상호작용을 시도합니다.")
        
         # 1. Initiator가 Target에 대해 무슨 말을 할지 LLM으로 생성
         prompt = f"""
         # 지시사항
-        당신은 '{initiator.name}'입니다. 지금 당신은 '{target.name}'와 마주쳤습니다.
-        '{target.name}'에 대한 당신의 현재 생각과 감정을 바탕으로, 먼저 건넬 자연스러운 첫 마디를 생성하세요.
+        당신은 '{initiator.korean_name}'입니다. 지금 당신은 '{target.korean_name}'와 마주쳤습니다.
+        '{target.korean_name}'에 대한 당신의 현재 생각과 감정을 바탕으로, 먼저 건넬 자연스러운 첫 마디를 생성하세요.
         (예: "앨리스, 어제 시장에서 파는 그 옷 정말 예쁘더라.", "밥, 요즘 허리가 아프다던데 괜찮아?")
 
         # 당신의 정보
-        - '{target.name}'와의 관계: {initiator.relationships.get_relationship_summary(target.name)}
+        - '{target.korean_name}'와의 관계: {initiator.relationships.get_relationship_summary(target.name)}
 
         → 첫 마디:
         """
         initial_utterance = query_llm_with_prompt(prompt).replace("'", "").strip()
 
         if "[LLM Error]" in initial_utterance:
-            print(f"[{initiator.name}] 대화 시작에 실패했습니다.")
+            print(f"[{initiator.korean_name}] 대화 시작에 실패했습니다.")
             return None, None
 
-        print(f"[{initiator.name}]: {initial_utterance}")
+        print(f"[{initiator.korean_name}]: {initial_utterance}")
 
         # 2. Target이 Initiator의 말을 듣고 응답 생성
         # generate_dialogue 함수를 재사용하되, target_npc 인자를 전달
@@ -85,7 +101,7 @@ class NPCManager:
             target_npc=initiator
         )
 
-        print(f"[{target.name}]: {response_utterance}")
+        print(f"[{target.korean_name}]: {response_utterance}")
         print("-------------------------\n")
         return initiator, target, initial_utterance
 

npc_social_network/npc/npc_planner.py

@@ -47,17 +47,17 @@ class PlannerManager:
         
         # LLM에게 전달할 NPC 상태 요약
         state_summary = f"""
-            # 당신의 현재 상태 요약
+            # 나의 현재 상태 요약
             - 주요 감정: {self.npc.summarize_emotional_state()}
             - 최근 기억 3개:
             {chr(10).join([f'  - {mem.content}' for mem in self.npc.memory_store.get_recent_memories(limit=3)])}
-            - 플레이어와의 관계: {self.npc.get_relationship_description("플레이어")}
+            - 플레이어와의 관계: {self.npc.get_relationship_description("player")}
         """
 
         prompt = f"""
             # 지시사항
-            → 당신은 '{self.npc.name}'입니다. 당신의 현재 상태를 바탕으로, 지금 가장 중요하게 추구추구해야 할 장기적인 목표를 한 문장으로 제안하세요.
-            → 목표는 당신의 삶을 더 낫게 만들거나, 문제를 해결하거나, 관계를 개선하는 것이어야 합니다.
+            → 나는 '{self.npc.korean_name}'입니다. 나의 현재 상태를 바탕으로, 지금 가장 중요하게 추구추구해야 할 장기적인 목표를 한 문장으로 제안하세요.
+            → 목표는 나의 삶을 더 낫게 만들거나, 문제를 해결하거나, 관계를 개선하는 것이어야 합니다.
 
             {state_summary}
 
@@ -68,10 +68,10 @@ class PlannerManager:
 
         if goal_description and "[LLM Error]" not in goal_description:
             self.current_goal = Goal(description=goal_description)
-            print(f"[{self.npc.name}의 새로운 목표] {self.current_goal.description}")
+            print(f"[{self.npc.korean_name}의 새로운 목표] {self.current_goal.description}")
             self.create_plan_for_goal()
         else:
-            print(f"[{self.npc.name}] 목표 생성에 실패했습니다.")
+            print(f"[{self.npc.korean_name}] 목표 생성에 실패했습니다.")
 
     def create_plan_for_goal(self):
         """
@@ -82,13 +82,11 @@ class PlannerManager:
         
         prompt = f"""
         # 지시사항
-        → 당신은 '{self.npc.name}'입니다. 당신의 목표는 '{self.current_goal.description}'입니다.
+        → 나는 '{self.npc.korean_name}'입니다. 나의 목표는 '{self.current_goal.description}'입니다.
         → 이 목표를 달성하기 위한 3~5개의 구체적이고 실행 가능한 행동 단계를 번호 목록으로 작성해주세요.
         → 각 단계는 짧은 문장으로 표현하세요,
 
         → 계획:
-
-        1. 
         """
         plan_text = "1. " + query_llm_with_prompt(prompt).replace("계획:", "").strip()
         steps = [step.strip() for step in plan_text.split('\n') if step.strip()]
@@ -98,7 +96,7 @@ class PlannerManager:
 
         if cleaned_steps:
             self.current_plan = Plan(goal=self.current_goal, steps=cleaned_steps)
-            print(f"[{self.npc.name}의 계획 수립]")
+            print(f"[{self.npc.korean_name}의 계획 수립]")
             for i, step in enumerate(self.current_plan.steps):
                 print(f"  - {i+1}단계: {step}")
 
@@ -113,13 +111,13 @@ class PlannerManager:
         step_index = plan.current_step_index
 
         if step_index >= len(plan.steps):
-            print(f"[{self.npc.name}] 목표 달성: {plan.goal.description}")
+            print(f"[{self.npc.korean_name}] 목표 달성: {plan.goal.description}")
             plan.goal.status = "completed"
             self.current_plan = None
             return f"({plan.goal.description} 목표를 달성하여 만족스럽습니다.)"
         
         current_step = plan.steps[step_index]
-        print(f"[{self.npc.name}의 행동 계획 실행] {step_index + 1}/{len(plan.steps)}: {current_step}")
+        print(f"[{self.npc.korean_name}의 행동 계획 실행] {step_index + 1}/{len(plan.steps)}: {current_step}")
 
         # 다음 단계로
         plan.current_step_index += 1

npc_social_network/npc/npc_relationship.py

@@ -5,6 +5,7 @@ from typing import List, Optional, TYPE_CHECKING
 if TYPE_CHECKING:
     from .npc_memory import Memory
     from .npc_base import NPC
+    from .npc_manager import NPCManager
 
 class SocialProfile:
     """특정 대상과의 사회적 관계를 종합적으로 관리하는 클래스"""
@@ -78,7 +79,7 @@ class RelationshipManager:
         profile = self._get_or_create_profile(target_name)
         return profile.summary
     
-    def summarize_relationship(self, target_name: str):
+    def summarize_relationship(self, target_name: str, npc_manager: "NPCManager"):
         """ LLM을 사용하여 특정 대상과의 관계를 주기적으로 요약하고 업데이트"""
         from ..models.llm_helper import query_llm_with_prompt
         profile = self._get_or_create_profile(target_name)
@@ -86,21 +87,24 @@ class RelationshipManager:
         if not profile.key_memories:
             return # 요약할 기억이 없으면 실행 안함
         
+        target_npc = npc_manager.get_npc_by_korean_name(target_name)
+        target_korean_name = target_npc.korean_name if target_npc else target_name
+
         memory_details = "\n".join([f"- {mem.content} (감정: {mem.emotion})" for mem in profile.key_memories])
         prompt = f"""
         # 지시사항
-        당신은 '{self.owner_npc.name}'입니다. 당신의 기억을 바탕으로 '{target_name}'에 대한 당신의 생각과 감정을 한두 문장으로 솔직하게 요약해주세요.
+        당신은 '{self.owner_npc.korean_name}'입니다. 당신의 기억을 바탕으로 '{target_korean_name}'에 대한 당신의 생각과 감정을 한두 문장으로 솔직하게 요약해주세요.
 
-        # '{target_name}'와(과)의 핵심 기억들
+        # '{target_korean_name}'와(과)의 핵심 기억들
         {memory_details}
 
-        → '{target_name}'에 대한 나의 생각:
+        → '{target_korean_name}'에 대한 나의 생각:
         """
         
         summary = query_llm_with_prompt(prompt).replace("'", "").strip()
 
         if summary and "[LLM Error]" not in summary:
             profile.summary = summary
-            print(f"[{self.owner_npc.name}의 관계 요약 업데이트] → {target_name}: {profile.summary}")
+            print(f"[{self.owner_npc.korean_name}의 관계 요약 업데이트] → {target_korean_name}: {profile.summary}")
 
     

npc_social_network/routes/npc_route.py

@@ -13,15 +13,6 @@ npc_bp = Blueprint(
     static_folder="../static"
 )
 
-# --- 한글 이름을 안전한 영어 파일명/ID로 변환하는 함수 ---
-def to_english_id(name):
-    name_map = {
-        "엘린": "elin", "밥": "bob", "앨리스": "alice",
-        "찰리": "charlie", "다이애나": "diana"
-    }
-    return name_map.get(name, name.lower().replace(" ", "_"))
-
-
 @npc_bp.route("/")
 def dashboard():
     return render_template("dashboard.html")
@@ -38,12 +29,12 @@ def get_world_state():
     nodes = []
     for npc in all_npcs:
         # 각 NPC의 영어 ID를 기반으로 이미지 파일명을 생성합니다. (예: elin -> npc_elin.png)
-        image_filename = f"images/npc/npc_{to_english_id(npc.name)}.png"
+        image_filename = f"images/npc/npc_{npc.name}.png"
 
         nodes.append({
             # id는 영어로, label은 한글로 분리
-            "id": to_english_id(npc.name),
-            "label": npc.name,
+            "id": npc.name,
+            "label": npc.korean_name,
             "shape": "image",  # 노드 모양을 'image'로 지정합니다.
             "image": url_for('npc_social.static', filename=image_filename), # 올바른 이미지 경로를 생성합니다.
             "size": 40 # 이미지 크기를 적절히 조절합니다.
@@ -53,8 +44,8 @@ def get_world_state():
     drawn_relations = set()
     for npc in all_npcs:
         for target_name, profile in npc.relationships.relationships.items():
-            from_id = to_english_id(npc.name)
-            to_id = to_english_id(target_name)
+            from_id = npc.name
+            to_id = target_name
             
             relation_pair = tuple(sorted((from_id, to_id)))
             if relation_pair in drawn_relations: continue
@@ -100,7 +91,7 @@ def inject_event():
     npc_name, event_text = data.get("npc_name"), data.get("event_text")
     
     with simulation_core.simulation_lock:
-        npc = simulation_core.npc_manager.get_npc_by_name(npc_name)
+        npc = simulation_core.npc_manager.get_npc_by_korean_name(npc_name)
         if npc and event_text:
             npc.remember(content=f"[요약된 기억] {event_text}", importance=10, emotion="surprise", memory_type="Summary")      # 수정 필요: 신이 돼서 넣는게 아니라, NPC가 마치 과거에 겪은 일처럼 자연스럽게 느끼도록
             simulation_core.add_log(f"이벤트 주입(기억 요약) -> {npc_name}: '{event_text}'")
@@ -111,12 +102,12 @@ def inject_event():
 @npc_bp.route("/api/npc_details/<npc_name>", methods=['GET'])
 def get_npc_details(npc_name):
     with simulation_core.simulation_lock:
-        npc = simulation_core.npc_manager.get_npc_by_name(npc_name)
+        npc = simulation_core.npc_manager.get_npc_by_korean_name(npc_name)
         if not npc:
             return jsonify({"error": "NPC not found"}), 404
 
         details = {
-            "name": npc.name, "age": npc.age, "job": npc.job,
+            "name": npc.korean_name, "age": npc.age, "job": npc.job,
             "personality_summary": npc.personality.get_personality_summary(),
             "emotions": npc.get_composite_emotion_state(top_n=5),
             "goals": npc.planner.current_goal.description if npc.planner.has_active_plan() else "특별한 목표 없음",

npc_social_network/scenarios/scenario_setup.py

@@ -1,6 +1,6 @@
 from ..npc.npc_manager import NPCManager
 from ..npc.npc_base import NPC
-from ..npc.npc_memory import Memory
+from ..npc.npc_memory_embedder import embed_npc_memories
 
 def setup_initial_scenario() -> NPCManager:
     """
@@ -15,23 +15,23 @@ def setup_initial_scenario() -> NPCManager:
     # --- 1. NPC 객체 생성 ---
     # 엘린: 호기심 많고 감정적인 마법사
     personality_elin = {"sensitive": 0.8, "stoic": 0.3, "cognitive_bias": 0.7}
-    elin = NPC("엘린", "마법사", personality=personality_elin)
+    elin = NPC('elin', "엘린", "마법사", personality=personality_elin)
 
     # 밥: 무뚝뚝하지만 정직한 대장장이
     personality_bob = {"sensitive": 0.2, "stoic": 0.8, "cognitive_bias": 0.4}
-    bob = NPC("밥", "대장장이", personality=personality_bob)
+    bob = NPC('bob', "밥", "대장장이", personality=personality_bob)
 
     # 앨리스: 사교적이고 계산적인 상인
     personality_alice = {"sensitive": 0.5, "stoic": 0.5, "cognitive_bias": 0.8}
-    alice = NPC("앨리스", "상인", personality=personality_alice)
+    alice = NPC('alice', "앨리스", "상인", personality=personality_alice)
 
     # 찰리: 성실하고 평화로운 농부
     personality_charlie = {"sensitive": 0.6, "stoic": 0.6, "cognitive_bias": 0.3}
-    charlie = NPC("찰리", "농부", personality=personality_charlie)
+    charlie = NPC('charlie', "찰리", "농부", personality=personality_charlie)
     
     # 다이애나: 조용하고 관찰력 있는 사서
     personality_diana = {"sensitive": 0.7, "stoic": 0.7, "cognitive_bias": 0.9}
-    diana = NPC("다이애나", "사서", personality=personality_diana)
+    diana = NPC('diana', "다이애나", "사서", personality=personality_diana)
 
     # --- 2. 초기 기억 주입 ---
     elin.remember(content="어젯밤 앨리스와 시장 가격 때문에 크게 다퉜다.", importance=8, emotion="anger")
@@ -49,15 +49,20 @@ def setup_initial_scenario() -> NPCManager:
 
     # --- 4. 초기 관계 설정 ---
     # 엘린 <-> 앨리스 (나쁜 관계)
-    elin.relationships.update_relationship("앨리스", "anger", strength=5.0)
-    alice.relationships.update_relationship("엘린", "resentment", strength=4.0)
+    elin.relationships.update_relationship("alice", "anger", strength=5.0)
+    alice.relationships.update_relationship("elin", "resentment", strength=4.0)
 
     # 밥 <-> 찰리 (좋은 관계)
-    bob.relationships.update_relationship("찰리", "gratitude", strength=6.0)
-    charlie.relationships.update_relationship("밥", "joy", strength=7.0)
+    bob.relationships.update_relationship("charlie", "gratitude", strength=6.0)
+    charlie.relationships.update_relationship("bob", "joy", strength=7.0)
     
     # 다이애나 -> 밥 (약간 부정적)
-    diana.relationships.update_relationship("밥", "disgust", strength=3.0)
+    diana.relationships.update_relationship("bob", "disgust", strength=3.0)
+
+    # 모든 NPC의 초기 기억을 FAISS 인덱스로 저장
+    print("모든 NPC의 초기 기억에 대한 FAISS 인덱스를 생성합니다...")
+    for npc in npc_manager.all():
+        embed_npc_memories(npc)
 
     print("✅ '시작의 마을' 시나리오 설정이 완료되었습니다.")
     return npc_manager

npc_social_network/simulation_core.py

@@ -30,16 +30,48 @@ def add_log(message):
 
 def tick_simulation():
     """시뮬레이션의 시간을 한 단계 진행"""
-    if not npc_manager or simulation_paused:
+    if not npc_manager:
         return
     
     with simulation_lock:
+        if simulation_paused:       # 정지 상태에서는 틱 실행 x
+            return
+        
         add_log("시뮬레이션 틱 시작")
 
         for npc in npc_manager.all():
             npc.decay_emotions()
             npc.decay_memories()
-            npc.update_autonomous_behavior("자율 행동 시간")
+            if random.random() < 0.1:
+                npc.update_autonomous_behavior("자율 행동 시간", npc_manager, add_log)
+
+        if len(npc_manager.all()) >= 3: # 목격자가 있으려면 최소 3명 필요
+            try:
+                add_log("NPC 간 자율 상호작용 및 목격 시도")
+                # 1. 상호작용을 호출하고 참여자들을 반환받음
+                initiator, target, initial_utterance = npc_manager.initiate_npc_to_npc_interaction("자율 행동 시간")
+
+                # 2. 상호작용이 성공했고, 목격자가 될 NPC가 있다면
+                if initiator and target:
+                    potential_witnesses = [npc for npc in npc_manager.all() if npc not in [initiator, target]]
+                    if potential_witnesses:
+                        witness = random.choice(potential_witnesses)
+
+                        # 3. 목격한 내용을 바탕으로 '소문' 기억 생성 (대화 내용 요약, 관계에 따른 거짓말 등 고도화 가능)
+                        gossip_content = f"'{initiator.name}'이(가) '{target.name}'에게 '{initial_utterance[:100]}...'라고 말하는 것을 봤다."
+
+                        # 4. 목격자가 '소문'을 기억하도록 함
+                        witness.remember(
+                            content=gossip_content,
+                            importance=4,
+                            emotion="curiosity",
+                            memory_type="Gossip",
+                            npc_manager = npc_manager
+                        )
+                        add_log(f"[목격] {witness.name}이(가) {initiator.name}와 {target.name}의 대화를 목격함.")
+
+            except Exception as e:
+                add_log(f"상호작용/목격 중 오류 발생: {e}")
 
         if len(npc_manager.all()) >= 2:
             try: