Complete step 19:인생 단계에 따른 NPC Personality 변화 적용

npc_social_network/models/llm_helper.py

@@ -32,4 +32,30 @@ def query_llm_for_emotion(user_input):
     반드시 감정 이름을 한 개만 출력하세요. (예: joy)
     """
     # 예시 결과 (추후 LLM 연결 시 교체)
-    return "joy"
+    return "joy"
+
+def query_llm_for_response_with_context(npc_name, npc_job, emotion_state, recent_memories,
+                                        personality, relationship_with_player):
+    """
+    LLM에 컨텍스트 정보를 전달하여 자연스러운 대사 생성
+    """
+    memory_text = "\n".join([f"- {m.content}" for m in recent_memories])
+    emotion_text = ", ".join([f"{emo}({score})" for emo, score in emotion_state])
+
+    # 최근 대화 내용은 기억에 다 들어가나?
+    # 행동이 들어갈 거니까, 기억도 단순 문장형이 아니라 가공해서 기억하고,
+    # 대화 내용은 가장 최근 대화 내용을 넘겨주는 방식이 좋을거 같은데, 시간이 지나면 잊혀지고
+    prompt = f"""
+        NPC 이름: {npc_name}
+        NPC 직업: {npc_job}
+        현재 감정 상태: {emotion_text}
+        최근 기억:
+        {memory_text}
+        현재 플레이어와의 관계: {relationship_with_player}
+        Personality: {personality}
+
+    위 정보를 참고하여, 한국어로 자연스럽고 상황에 맞는 대화 문장을 생성하세요.
+    """
+
+    # 임시 응답 (LLM 연결 시 교체)
+    return f"{npc_name}이(가) 말했습니다. '오늘은 기분이 좋아요!' "

npc_social_network/npc/emotion_config.py

@@ -153,4 +153,15 @@ NEGATIVE_RELATION_EMOTIONS = [
 COGNITIVE_RELATION_EMOTIONS = [
     "compassion", "awe", "attachment", "anticipation", "curiosity",
     "nostalgia", "bittersweet", "rumination", "groundedness", "comfort",
-]
+]
+
+# 인생 단계별 Personality 변화율 정의
+AGE_PROFILE = {
+    "infancy_and_toddlerhood": 3.0,  # (0-3 세) Temperament & attachment foundation — change rate very high
+    "early_childhood": 2.0,          # (3-6 세) Initial personality structure emergence — high change rate
+    "middle_childhood": 1.5,         # (6-12 세) Personality structure solidification — still high change rate
+    "adolescence": 1.0,              # (12-18 세) Identity formation — moderate to high change rate
+    "young_adulthood": 0.5,          # (18-30 세) Personality stabilization — moderate change rate
+    "middle_adulthood": 0.2,         # (30-65 세) Personality highly stable — low change rate
+    "older_adulthood": 0.02          # (65- 세) Personality largely fixed — minimal change
+}

npc_social_network/npc/npc_base.py

@@ -3,9 +3,9 @@ from .npc_memory import Memory, MemoryStore
 from .npc_emotion import EmotionManager
 from .npc_behavior import BehaviorManager
 from .emotion_config import EMOTION_LIST, EMOTION_CATEGORY_MAP, EMOTION_DECAY_RATE, PERSONALITY_TEMPLATE
-from .emotion_config import POSITIVE_RELATION_EMOTIONS, NEGATIVE_RELATION_EMOTIONS, COGNITIVE_RELATION_EMOTIONS
+from .emotion_config import POSITIVE_RELATION_EMOTIONS, NEGATIVE_RELATION_EMOTIONS, COGNITIVE_RELATION_EMOTIONS, AGE_PROFILE
 from .npc_relationship import RelationshipManager
-from ..models.llm_helper import query_llm_for_emotion, query_llm_for_response
+from ..models.llm_helper import query_llm_for_emotion, query_llm_for_response, query_llm_for_response_with_context
 import random
 import copy
 
@@ -62,16 +62,43 @@ class NPC:
         # baseline buffer를 EmotionManager에 등록
         self.emotion.set_baseline(baseline_buffer)
 
+        # Personality 성격 프로필 기반
+        # profile: stable / emotional / logical (추후 더 추가)
+        personality_profile = {
+            "stable": {
+                "sensitive": (0.002, 0.004),
+                "stoic": (0.002, 0.004),
+                "cognitive_bias": (0.002, 0.004)
+            },
+            "emotional":{
+                "sensitive": (0.006, 0.01),
+                "stoic": (0.002, 0.004),
+                "cognitive_bias": (0.004, 0.006)
+            },
+            "logical":{
+                "sensitive": (0.002, 0.004),
+                "stoic": (0.004, 0.006),
+                "cognitive_bias":(0.006, 0.01)
+            },
+        }
+
+        # 프로필 지정 → 기본은 "stable", 나중에 NPC마다 다르게 부여
+        profile_type = "stable"
+        profile = personality_profile[profile_type]
+        
         # Personality 변화 속도 개별 설정
         self.personality_change_rate = {
-            "sensitive": 0.005 + random.uniform(0, 0.005),
-            "stoic": 0.005 + random.uniform(0, 0.005),
-            "cognitive_bias": 0.005 + random.uniform(0, 0.005),
+            "sensitive": random.uniform(*profile["sensitive"]),
+            "stoic": random.uniform(*profile["stoic"]),
+            "cognitive_bias": random.uniform(*profile["cognitive_bias"]),
         }
 
         # Personality baseline 저장 (초기값 복사)
         self.personality_baseline = copy.deepcopy(self.personality)
 
+        # 인생 단계 profile 추가
+        self.personality_stage = "adolescence"    # 기본 "adolescence", NPC마다 다르게 설정 가능
+
     def move(self):
         """
         이동
@@ -91,50 +118,82 @@ class NPC:
         x, y = self.get_position()
         screen.blit(self.image, (x * tile_size, y * tile_size))
 
-    def generate_dialogue(self):
-        """
-        감정 상태와 직업에 따른 복합 행동 시퀀스 기반 대사 생성 + Behavior Trace Memory 기록
-        """
-        behavior_output, behavior_trace = self.behavior.perform_sequence(
-            self.name, self.job, emotion_buffer=self._emotion_buffer, return_trace = True
-        )
-        
-        # 단계별 dominant emotion sequence 계산
-        dominant_emotions = self.behavior.get_layer_dominant_emotions(self._emotion_buffer)
-        dominant_sequence = self.behavior.decide_layered_sequence(dominant_emotions)
-
-        # dominant_sequence가 empty인 경우 방어적 처리
-        if dominant_sequence:
-            dominant_score = max([score for _, score in dominant_sequence])
+    def generate_dialogue(self, use_llm=True):
+        """
+        대화 생성 함수
+        """       
+        if use_llm:
+            # LLM 기반 generate
+            npc_reply = query_llm_for_response_with_context(
+                npc_name = self.name,
+                npc_job = self.job,
+                emotion_state = self.get_composite_emotion_state(),
+                recent_memories = self.memory_store.get_recent_memories(limit=5),
+                personality = self.personality,
+                relationship_with_player = self.get_relationship_description("플레이어"),
+            )
+
+            # Memory 기록
+            self.remember(
+                content = f"[NPC: {self.name}] LLM 대사: '{npc_reply}'",
+                importance = 7,
+                emotion = self.emotion.get_dominant_emotion()
+            )
+
+            # Personality 업데이트
+            self.update_personality()
+
+            # Emotion update는 LLM 기반 generate 에서는 따로 역매핑이 애매하므로 dominant_emotion만 반영 (원하면 감정 분석 결과 기반으로 개선 가능)
+            dominant_emotion = self.emotion.get_dominant_emotion()
+            if dominant_emotion:
+                self.update_emotion(dominant_emotion, strength=2.0)
+
+            return npc_reply
         else:
-            # dominant_sequence가 비었으면 기본값 사용 (예: 감정 없음 상태)
-            dominant_score = 5
-
-        # 중요도 제한
-        importance = min(int(dominant_score), 10)   # importance 1~10제한
-
-        # Behavior Trace를 Memory에 기록
-        memory_entry = Memory(
-            content=f"행동 수행: {behavior_trace}",
-            importance=importance,
-            emotion = self.emotion.get_dominant_emotion(),
-            behavior_trace = behavior_trace
-        )
-        self.memory_store.add_memory(memory_entry)
-
-        # 행동에 해당하는 감정에 update_emotion 호출 (정확하게 반영)
-        for action, score in behavior_trace:
-            emotion_name = self.behavior.action_to_emotion.get(action)
-            if emotion_name:
-                self.update_emotion(emotion_name, strength=score)
-
-        return behavior_output
+            # 감정 상태와 직업에 따른 복합 행동 시퀀스 기반 대사 생성 + Behavior Trace Memory 기록   
+            behavior_output, behavior_trace = self.behavior.perform_sequence(
+                self.name, self.job, emotion_buffer=self._emotion_buffer, return_trace = True
+            )
+
+            # 단계별 dominant emotion sequence 계산
+            dominant_emotions = self.behavior.get_layer_dominant_emotions(self._emotion_buffer)
+            dominant_sequence = self.behavior.decide_layered_sequence(dominant_emotions)
+
+            # dominant_sequence가 empty인 경우 방어적 처리
+            if dominant_sequence:
+                dominant_score = max([score for _, score in dominant_sequence])
+            else:
+                # dominant_sequence가 비었으면 기본값 사용 (예: 감정 없음 상태)
+                dominant_score = 5
+
+            # 중요도 제한
+            importance = min(int(dominant_score), 10)   # importance 1~10제한
+
+            # Behavior Trace를 Memory에 기록
+            memory_entry = Memory(
+                content=f"행동 수행: {behavior_trace}",
+                importance=importance,
+                emotion = self.emotion.get_dominant_emotion(),
+                behavior_trace = behavior_trace
+            )
+            self.memory_store.add_memory(memory_entry)
+
+            # 행동에 해당하는 감정에 update_emotion 호출 (역매핑)
+            for action, score in behavior_trace:
+                emotion_name = self.behavior.action_to_emotion.get(action)
+                if emotion_name:
+                    self.update_emotion(emotion_name, strength=score)
+
+            # Personality 업데이트
+            self.update_personality()
+
+            return behavior_output
     
-    def remember(self, content: str, importance: int = 5, emotion: str = None, strength: float = 1.0):
+    def remember(self, content: str, importance: int = 5, emotion: str = None, strength: float = 1.0, memory_type:str = "Event"):
         """
         NPC가 새로운 기억을 저장하고 감정 상태에 반영
         """
-        memory = Memory(content=content, importance = importance, emotion=emotion or "neutral")
+        memory = Memory(content=content, importance = importance, emotion=emotion or "neutral", memory_type=memory_type)
         self.memory_store.add_memory(memory)
         if emotion:
             self.update_emotion(emotion, strength)  # strength = importance / 5.0으로도 가능
@@ -322,14 +381,97 @@ class NPC:
     def update_personality(self):
         """
         Memory / Emotion 기반으로 Personality 변화 적용
-        """
+        - MemoryType 별 가중치 + EmotionInfluence 별 가중치 모두 반영
+        """
+        # MemoryType 별 weight
+        memory_type_weight = {
+            "Dialogue": 0.5,
+            "Behavior": 1.0,
+            "Event": 1.5,
+            "RelationshipChange": 2.0
+        }
+
+        # EmotionInfluence 별 weight
+        emotion_influence_weight = {
+            # Core
+            "joy": 0.8,
+            "sadness": 1.3,
+            "anger": 1.5,
+            "fear": 1.4,
+            "disgust": 1.2,
+            "surprise": 1.0,
+            "neutral": 0.5,
+
+            # Social
+            "gratitude": 0.9,
+            "shame": 1.3,
+            "guilt": 1.3,
+            "pride": 0.9,
+            "jealousy": 1.2,
+            "compassion": 1.1,
+            "love": 0.8,
+            "admiration": 0.9,
+            "empathy": 0.9,
+            "awe": 1.1,
+            "attachment": 1.0,
+            "comfort": 0.8,
+
+            # Cognitive
+            "anticipation": 0.7,
+            "curiosity": 0.7,
+            "confusion": 1.0,
+            "interest": 0.8,
+            "engagement": 0.8,
+            "boredom": 0.6,
+            "relief": 0.7,
+            "anxiety": 1.1,
+            "calm": 0.6,
+            "skepticism": 0.9,
+
+            # Complex
+            "nostalgia": 1.2,
+            "bittersweet": 1.1,
+            "schadenfreude": 1.4,
+            "hope": 1.0,
+            "resentment": 1.3,
+            "anticipatory_joy": 0.9,
+            "regret": 1.3,
+            "rumination": 1.4,
+            "groundedness": 0.8
+        }
+
         recent_memories = self.memory_store.get_recent_memories(limit=10)   # 최근 10개 Memory 사용(이것보단 중요도가 큰(즉 충격이 큰) 기억이 성격 형성에 영향을 주는게 자연스럽지)
 
         # Personality 변화 반영
         # 나중에 NPC 일정 나이가 되면 성격 형성이 되어 변경되지 않도록 발전 가능, 보다 인간적
         # 그리고 생성된 성격에 따라서 기억(사건)에 따른 감정 영향에 가중치를 받도록 확장 가능 (같은 사건이여도 성격에 따라 받아들이는게 다르도록)
         for m in recent_memories:
-            weight = m.importance / 10.0    # importance 1~10 → 0.1 ~ 1.0
+            # MemoryType 별 weight 적용
+            type_weight = memory_type_weight.get(m.memory_type, 1.0)    # 기본값 1.0
+            # EmotionInfluence 별 weight 적용
+            emotion_weight = emotion_influence_weight.get(m.emotion, 1.0)
+
+            # Personality bias 적용 (성격에 따라, 같은 사건에 받는 감정이 다르도록)
+            category = EMOTION_CATEGORY_MAP.get(m.emotion, "core")
+            if category == "core":
+                personality_bias = self.personality["affect_bias"]
+            elif category == "social":
+                personality_bias = self.personality["social_bias"]
+            elif category == "cognitive":
+                personality_bias = self.personality["cognitive_bias"]
+            elif category == "complex":
+                personality_bias = self.personality["complex_bias"]
+            else:
+                personality_bias = 1.0
+
+            # sensitive / stoic 반영
+            emotion_bias_factor = personality_bias * self.personality["sensitive"] * (1.0 - self.personality["stoic"])
+
+            # 인생 단계별 변화율 적용
+            stage_factor = AGE_PROFILE.get(self.personality_stage, 1.0)
+
+            # 최종 weight 계산
+            weight = stage_factor * (m.importance / 10.0) * type_weight * emotion_weight * emotion_bias_factor    # importance 1~10 → 0.1 ~ 1.0
             if m.emotion in POSITIVE_RELATION_EMOTIONS:
                 self.personality["sensitive"] = min(1.0, self.personality["sensitive"] + self.personality_change_rate["sensitive"] * weight)
                 self.personality["stoic"] = max(0.0, self.personality["stoic"] - self.personality_change_rate["stoic"] * weight)
@@ -340,12 +482,22 @@ class NPC:
             if m.emotion in COGNITIVE_RELATION_EMOTIONS:
                 self.personality["cognitive_bias"] = min(1.0, self.personality["cognitive_bias"] + self.personality_change_rate["cognitive_bias"] * weight)
 
-        # Baseline 복원 적용 (slow decay)
-        decay_rate = 0.001
+        # Baseline 복원 적용 (adaptive decay)
+        # decay_rate = base_rate * (1 + stoic - sensitive)
+        base_decay = 0.001
+        decay_rate = base_decay * (1.0 + self.personality["stoic"] - self.personality["sensitive"])
+        # 안정적 범위 클램핑
+        decay_rate = max(0.0005, min(decay_rate, 0.005))
 
         for key in self.personality.keys():
             self.personality[key] += (self.personality_baseline[key] - self.personality[key]) * decay_rate
 
         # 디버그 출력
         print(f"[Personality Update] {self.name} → sensitive: {self.personality['sensitive']:.2f}, "
-            f"stoic: {self.personality['stoic']:.2f}, cognitive_bias: {self.personality['cognitive_bias']:.2f}", flush=True)
+            f"stoic: {self.personality['stoic']:.2f}, cognitive_bias: {self.personality['cognitive_bias']:.2f}", flush=True)
+
+    def decay_memory(self):
+        """
+        시간이 지남에 따라 기억 importance 감소
+        """
+        self.memory_store.decay_memories()

npc_social_network/npc/npc_memory.py

@@ -12,14 +12,15 @@ class Memory:
     - is_long_term: 장기 기억 여부
     - behavior_trace: 기억을 통한 행동 추적
     """
-    def __init__(self, content: str, timestamp: datetime = None,
-                 importance: int = 1, emotion: str = "neutral", behavior_trace: str = None):
+    def __init__(self, content: str, timestamp: datetime = None, importance: int = 1,
+                 emotion: str = "neutral", behavior_trace: str = None, memory_type: str = "Event"):
         self.content = content
         self.timestamp = timestamp or datetime.now()
         self.importance = importance
         self.emotion = emotion 
         self.is_long_term = False
         self.behavior_trace = behavior_trace
+        self.memory_type = memory_type
 
 
 class MemoryStore:
@@ -70,3 +71,25 @@ class MemoryStore:
         all_memories = self.get_all_memories()
         all_memories.sort(key=lambda m: m.timestamp, reverse=True)
         return all_memories[:limit]
+    
+    def decay_memories(self, min_importance=1, decay_rate_short=0.05, decay_rate_long=0.01):
+        """
+        MemoryType에 따라 decay 적용
+        - 단기 기억은 decay_rate_short 만큼 importance 감소 (기본 5% 감소)
+        - 장기 기억은 decay_rate_long 만큼 importance 감소 (기본 1% 감소)
+        - 기억 타입에 따른 importance 차등 감소 (대화, 행동, 사건, 관계)
+        """
+        decay_rates = {
+            "Dialogue": 0.10,           # 대화 (빠른 decay)
+            "Behavior": 0.05,           # 행동
+            "Event": 0.02,              # 사건
+            "RelationshipChange": 0.01  # 관계 (느린 decay)
+        }
+
+        for mem in self.short_term:
+            rate = decay_rates.get(mem.memory_type, 0.05)
+            mem.importance = max(min_importance, mem.importance * (1.0 - decay_rate_short) * (1.0 - rate))
+
+        for mem in self.long_term:
+            rate = decay_rates.get(mem.memory_type, 0.02)
+            mem.importance = max(min_importance, mem.importance * (1.0 - decay_rate_long) * (1.0 - rate))