감정 모델 리팩토링 테스트

npc_social_network/npc/emotion_config.py

@@ -1,161 +1,138 @@
 # portfolio/npc_social_network/npc/emotion_config.py
 # 감정 초기 상태 및 decay 설정
 
-# 고차원 감정 상태 정의 (GoEmotions 기반, 보여주기용, 지금 내용은 엉망)
-# 예 1) 친구가 내 생일 파티를 열어줬다.( 기쁨 + ?? + 흥분)
-# 예 2) 과거 좋았던 일이 생각난다 (기쁨 + ?? + 몰입)
-# 예 3) 슬픈 일이지만, 어쩔 수 없다고 생각한다. (슬픔 + 공감 + 회의)
-# 예 4) 내가 싫어하는 사람이 사고를 당했다는 소식을 들어 기쁘다. (기쁨 + ?? + ??)
+# 고차원 감정 상태 정의
+# 균형 잡힌 복합 감정 모델 정의를 위해 GoEmotions 바탕으로 설계 (ComplexEmotions이라 명명)
+EMOTION_LIST = [
+    # Core Emotions (기본 감정)
+    # 기쁨, 슬픔, 분노, 공포, 혐오,
+    # 놀람, 중립
+    "joy", "sadness", "anger", "fear", "disgust",
+    "surprise", "neutral",
+
+    # Social Emotions (사회적 감정)
+    # 감사, 수치심, 죄책감, 자부심, 질투, 연민/동정,
+    # 사랑/애정, 존경/감탄, 공감, 경외심, 애착, 위로 추구
+    "gratitude", "shame", "guilt", "pride", "jealousy", "compassion",
+    "love", "admiration", "empathy", "awe", "attachment", "comfort",
+
+    # Cognitive States (인지적 상태)
+    # 기대, 호기심, 혼란, 흥미, 몰입
+    # 지루함, 안도, 불안/긴장, 평온, 회의
+    "anticipation", "curiosity", "confusion", "interest", "engagement",
+    "boredom", "relief", "anxiety", "calm", "skepticism",
+
+    # Complex Emotions (복합 감정)
+    # 향수, 달콤쌉싸름함, 남의 불행에서 느끼는 행복, 희망, 분개
+    # 기대 속의 기쁨, 후회, 반추, 안정감
+    "nostalgia", "bittersweet", "schadenfreude", "hope", "resentment",
+    "anticipatory_joy", "regret", "rumination", "groundedness",
+]
 
-EMOTION_STATE_TEMPLATE = {
-    # 기본 정서 (긍정)
-    "core_positive":{
-        "joy": 0,           # 기쁨
-        "satisfaction": 0,  # 만족
-        "gratitude": 0,     # 감사
-        "calm": 0,          # 평온
-        "anticipation": 0,  # 기대
-        "pride": 0,         # 자부심
-        "connectedness": 0  # 유대감
-    },
-    # 기본 정서 (부정)
-    "core_negative": {
-            "sadness": 0,       # 슬픔
-            "anger": 0,         # 분노
-            "anxiety": 0,       # 불안
-            "disgust": 0,       # 혐오
-            "fear": 0,          # 공포
-            "regret": 0,        # 후회
-            "frustration": 0    # 좌절
-    },
-    # 사회적 감정
-    "social_emotion": {
-        "jealousy": 0,      # 질투
-        "shame": 0,         # 수치심
-        "guilt": 0,         # 죄책감
-        "compassion": 0,    # 동정심
-        "awe": 0,           # 경외심
-        "empathy": 0        # 공감
-    },
-    # 인지적 상태
-    "cognitive_state": {
-        "confusion": 0,     # 혼란
-        "nervousness": 0,   # 긴장
-        "apathy": 0,        # 무관심
-        "excitement": 0,    # 흥분
-        "immersion": 0,     # 몰입
-        "skepticism": 0     # 회의
-    }
+# 감정 : 카테고리 맵
+EMOTION_CATEGORY_MAP = {
+    # Core
+    "joy": "core",
+    "sadness": "core",
+    "anger": "core",
+    "fear": "core",
+    "disgust": "core",
+    "surprise": "core",
+    "neutral": "core",
+
+    # Social
+    "gratitude": "social",
+    "shame": "social",
+    "guilt": "social",
+    "pride": "social",
+    "jealousy": "social",
+    "compassion": "social",
+    "love": "social",
+    "admiration": "social",
+    "empathy": "social",
+    "awe": "social",
+    "attachment": "social",
+    "comfort": "social",
+
+    # Cognitive
+    "anticipation": "cognitive",
+    "curiosity": "cognitive",
+    "confusion": "cognitive",
+    "interest": "cognitive",
+    "engagement": "cognitive",
+    "boredom": "cognitive",
+    "relief": "cognitive",
+    "anxiety": "cognitive",
+    "calm": "cognitive",
+    "skepticism": "cognitive",
+
+    # Complex
+    "nostalgia": "complex",
+    "bittersweet": "complex",
+    "schadenfreude": "complex",
+    "hope": "complex",
+    "resentment": "complex",
+    "anticipatory_joy": "complex",
+    "regret": "complex",
+    "rumination": "complex",
+    "groundedness": "complex",
 }
 
 # 감정별 회복 속도 (ms 단위가 아닌 단위당 감소 속도)
 EMOTION_DECAY_RATE = {
-# 기본 정서 (긍정)
-    "joy": 0.7,           # 기쁨
-    "satisfaction": 0.8,  # 만족
-    "gratitude": 0.4,     # 감사
-    "calm": 0.2,          # 평온
-    "anticipation": 0.6,  # 기대
-    "pride": 0.8,         # 자부심
-    "connectedness": 0.5,  # 유대감
-
-# 기본 정서 (부정) - 느림
-    "sadness": 0.2,       # 슬픔
-    "anger": 0.5,         # 분노
-    "anxiety": 0.4,       # 불안
-    "disgust": 0.8,       # 혐오
-    "fear": 0.6,          # 공포
-    "regret": 0.3,        # 후회
-    "frustration": 0.5,    # 좌절
-
-# 사회적 감정
-    "jealousy": 0.4,      # 질투
-    "shame": 0.4,         # 수치심
-    "guilt": 0.4,         # 죄책감
-    "compassion": 0.8,    # 동정심
-    "awe": 0.8,           # 경외심
-    "empathy": 1,        # 공감
-
-# 인지적 상태
-    "confusion": 0.8,     # 혼란
-    "nervousness": 0.7,   # 긴장
-    "apathy": 0.4,        # 무관심
-    "excitement": 0.9,    # 흥분
-    "immersion": 0.6,     # 몰입
-    "skepticism": 0.5,     # 회의
+    # Core (기본 감정)
+    "joy": 0.6,                 # 기쁨
+    "sadness": 0.3,             # 슬픔
+    "anger": 0.4,               # 분노
+    "fear": 0.4,                # 공포
+    "disgust": 0.5,             # 혐오
+    "surprise": 0.8,            # 놀람
+    "neutral": 1.2,             # 중립
+
+    # Social (사회적 감정)
+    "gratitude": 0.6,           # 감사
+    "shame": 0.3,               # 수치심
+    "guilt": 0.3,               # 죄책감
+    "pride": 0.6,               # 자부심
+    "jealousy": 0.4,            # 질투
+    "compassion": 0.7,          # 연민/동정
+    "love": 0.2,                # 사랑/애정
+    "admiration": 0.7,          # 존경/감탄
+    "empathy": 0.7,             # 공감
+    "awe": 0.8,                 # 경외심
+    "attachment": 0.2,          # 애착
+    "comfort": 0.6,             # 위로 추구
+
+    # Cognitive (인지적 상태)
+    "anticipation": 0.6,        # 기대
+    "curiosity": 0.8,           # 호기심
+    "confusion": 0.5,           # 혼란
+    "interest": 0.8,            # 흥미
+    "engagement": 0.7,          # 몰입
+    "boredom": 0.4,             # 지루함
+    "relief": 0.8,              # 안도
+    "anxiety": 0.5,             # 불안/긴장
+    "calm": 0.7,                # 평온
+    "skepticism": 0.5,          # 회의
+
+    # Complex (복합 감정)
+    "nostalgia": 0.2,           # 향수
+    "bittersweet": 0.3,         # 달콤쌉싸름함
+    "schadenfreude": 0.5,       # 남의 불행에서 느끼는 기쁨
+    "hope": 0.6,                # 희망
+    "resentment": 0.4,          # 분개
+    "anticipatory_joy": 0.6,    # 기대 속의 기쁨
+    "regret": 0.3,              # 후회
+    "rumination": 0.3,          # 반추
+    "groundedness": 0.8         # 안정감
 }
 
 # 개성 템플릿(0~1 범위)
 PERSONALITY_TEMPLATE = {
-    "sensitive" : 0.8,          # 감정 반응 강도 증가
-    "stoic": 0.2,               # 감정 반응 둔화
-    "positive_bias": 0.6,       # 긍정 감정에 민감
-    "negative_bias": 0.4,       # 부정 감정에 민감
-    "sociality" : 0.5,          # 사회적 감정 민감
-}
-
-# 긍정/부정 감정 전역 리스트
-AFFECT_EMOTIONS = {
-    "positive": ["joy", "satisfaction", "gratitude", "calm", "anticipation", "pride", "connectedness"],
-    "negative": ["sadness", "anger", "anxiety", "disgust", "fear", "regret", "frustration"]
-}
-
-# 사회적 감정 전역 리스트
-SOCIAL_EMOTIONS = [
-    "jealousy", "shame", "guilt", "compassion", "awe", "empathy"
-]
-
-# 인지적 감정 전역 리스트
-COGNITIVE_STATES = [
-    "confusion", "nervousness", "apathy", "excitement", "immersion", "skepticism"
-]
-
-
-"""
-🌟 균형 잡힌 복합 감정 모델 정의( 이쪽으로 변형하는게 더 고차원 일 것 같음, ComplexEmotions)
-1️⃣ 기본 감정 (Core Emotions)
-Joy (기쁨)
-Sadness (슬픔)
-Anger (분노)
-Fear (공포)
-Disgust (혐오)
-Surprise (놀람)
-
-2️⃣ 사회적 감정 (Social Emotions)
-Gratitude (감사)
-Shame (수치심)
-Guilt (죄책감)
-Pride (자부심)
-Jealousy (질투)
-Compassion (연민/동정)
-Love (사랑/애정)
-Admiration (존경/감탄)
-Empathy (공감)
-Awe (경외심)
-Attachment (애착)
-Comfort (위로 추구)
-
-3️⃣ 인지적 상태 (Cognitive States)
-Anticipation (기대)
-Curiosity (호기심)
-Confusion (혼란)
-Interest (흥미)
-Engagement (몰입)
-Boredom (지루함)
-Relief (안도)
-Anxiety (불안 / 긴장)
-Calm (평온)
-
-Skepticism (회의)
-
-4️⃣ 복합 감정 (Mixed / Complex Emotions)
-Nostalgia (향수)
-Bittersweet (달콤쌉싸름함)
-Schadenfreude (남의 불행에서 느끼는 기쁨)
-Hope (희망)
-Resentment (분개)
-Anticipatory joy (기대 속의 기쁨)
-Regret (후회)
-Rumination (반추)
-Groundedness (안정감)
-"""
+    "affect_bias": 1.0,      # Core emotion 영향
+    "social_bias": 1.0,      # Social emotion 영향
+    "cognitive_bias": 1.0,   # Cognitive state 영향
+    "complex_bias": 1.0,     # Complex emotion 영향
+    "sensitive": 1.0,        # 전체 감정 반응 강도
+    "stoic": 0.0             # 전체 감정 둔화 정도 (감쇠 가속도에 영향)
+}

npc_social_network/npc/npc_base.py

@@ -2,12 +2,21 @@
 from .npc_memory import Memory, MemoryStore
 from .npc_emotion import EmotionManager
 from .npc_behavior import BehaviorManager
-from .emotion_config import EMOTION_STATE_TEMPLATE, EMOTION_DECAY_RATE, PERSONALITY_TEMPLATE
+from .emotion_config import EMOTION_CATEGORY_MAP, EMOTION_DECAY_RATE, PERSONALITY_TEMPLATE
 from .npc_relationship import RelationshipManager
 
-# 감정의 기본 성향 정의
-positive_emotions = ["joy", "gratitude", "connectedness", "empathy", "pride"]
-negative_emotions = ["anger", "disgust", "fear", "regret", "shame"]
+# 관계에 긍/부정 영향으로 해석할 감정 매핑 정의 (논문 설계 기반 적용)
+POSITIVE_RELATION_EMOTIONS = [
+    "joy", "surprise", "gratitude", "pride", "love",
+    "admiration", "empathy", "comfort", "hope", "anticipatory_joy",
+    "calm", "engagement", "relief", "interest",
+]
+
+NEGATIVE_RELATION_EMOTIONS = [
+    "sadness", "anger", "fear", "disgust", "shame",
+    "guilt", "jealousy", "resentment", "regret", "schadenfreude",
+    "anxiety", "confusion", "skepticism", "boredom",
+]
 
 # NPC 클래스 정의
 class NPC:
@@ -26,12 +35,11 @@ class NPC:
         # npc 기억
         self.memory_store = MemoryStore()
         # 감정 상태 등 감정 관리자 초기화
-        self.emotion_state = EMOTION_STATE_TEMPLATE
         self.emotion_decay_rate = EMOTION_DECAY_RATE
         self.personality = personality or PERSONALITY_TEMPLATE
         self.relationships = RelationshipManager()   # 관계 시스템 초기화
 
-        self.emotion = EmotionManager(self.emotion_state, self.emotion_decay_rate, self.personality)
+        self.emotion = EmotionManager(self.emotion_decay_rate, self.personality)
 
         # 행동 관리자
         self.behavior = BehaviorManager()
@@ -66,7 +74,18 @@ class NPC:
         감정 상태와 직업에 따른 복합 행동 시퀀스 기반 대사 생성
         """
         composite = self.get_composite_emotion_state(top_n=3)   # 상위 3개 감정 사용
-        return self.behavior.perform_sequence(self.name, self.job, composite)
+        behavior_output, behavior_trace = self.behavior.perform_sequence(
+            self.name, self.job, emotion_buffer=self._emotion_buffer, return_trace = True
+        )
+        # Behavior Trace를 Memory에 기록
+        memory_entry = Memory(
+            content=f"행동 수행: {behavior_trace}",
+            importance=5, # 기본 importance (튜닝 가능)
+            emotion = self.emotion.get_dominant_emotion(),
+            behavior_trace = behavior_trace
+        )
+        self.memory_store.add_memory(memory_entry)
+        return behavior_output
     
     def remember(self, content: str, importance: int = 5, emotion: str = None, strength: float = 1.0):
         """
@@ -132,11 +151,11 @@ class NPC:
         base = 5.0 # 기본 영향력
 
         # 감정 종류별 base 수정
-        if emotion in positive_emotions:
+        if emotion in POSITIVE_RELATION_EMOTIONS:
             base += 2.0
             # 긍정 감정은 positive = True일 때만 +로 반영, positive = False일 경우 최소한으로 영향
             return base if positive else 0.0
-        elif emotion in negative_emotions:
+        elif emotion in NEGATIVE_RELATION_EMOTIONS:
             base += 3.0
             # 부정 감정은 positive = False일 때만 -로 반영, positive = True일 경우 최소한으로 영향
             return -base if not positive else 0.0
@@ -163,23 +182,15 @@ class NPC:
         for mem in memories[-5:]:   # 최근 5개 기억 기준
             if mem.importance >= 7: # 중요 기억만 반영
                 # 감정 성향에 따라 positive 결정 및 영향력 계산
-                if mem.emotion in positive_emotions:
-                    delta = self._get_emotion_influence(mem.emotion, positive=True if mem.importance >= 7 else False)
-                elif mem.emotion in negative_emotions:
-                    delta = self._get_emotion_influence(mem.emotion, positive=False if mem.importance >= 4 else True)
-                else:
-                    delta = 0.0
+                # 중요 기억만 반영
+                is_positive = mem.emotion in POSITIVE_RELATION_EMOTIONS
+                delta = self._get_emotion_influence(mem.emotion, positive=is_positive)
                 base_influence += delta
 
-        # 현재 감정 상태 영향 추가 반영
+        # 현재 감정 상태 영향 추가 반영 (보조적 반영)
         if dominant_emotion:
-            if dominant_emotion in positive_emotions:
-                emo_influence = self._get_emotion_influence(dominant_emotion, positive=True)
-            elif dominant_emotion in negative_emotions:
-                emo_influence = self._get_emotion_influence(dominant_emotion, positive=False)
-            else:
-                emo_influence = 0.0
-                
+            is_positive = dominant_emotion in POSITIVE_RELATION_EMOTIONS
+            emo_influence = self._get_emotion_influence(dominant_emotion, positive=is_positive)                
             base_influence += emo_influence * 0.5 # 현재 감정은 보조적 영향
 
         # 관계 갱신

npc_social_network/npc/npc_behavior.py

@@ -1,83 +1,168 @@
 # 감정-행동 연동 매핑 및 행동 생성
 # portfolio/npc_social_network/npc/npc_behavior.py
 
+from .emotion_config import EMOTION_CATEGORY_MAP
+
 class BehaviorManager:
     def __init__(self):
         self.mapping = {
-                        # 기본 정서 (긍정)
-                        "joy": "jump",              # 기쁨 : 점프 뛰다
-                        "satisfaction": "nod",      # 만족 : 고개를 끄덕이다
-                        "gratitude": "thank",       # 감사 : 감사하다
-                        "calm": "relax",            # 평온 : 진정하다
-                        "anticipation": "prepare",  # 기대 : 준비하다
-                        "pride": "show_off",        # 자부심 : 자랑하다
-                        "connectedness": "wave",    # 유대감 : 손을 흔들다
+            # Core (기본 감정)
+            "joy": "jump",                  # 기쁨 : 점프 뛰다
+            "sadness": "sit_down",          # 슬픔 : 주저 앉다
+            "anger": "shout",               # 분노 : 소리치다
+            "fear": "run_away",             # 공포 : 도망치다
+            "disgust": "avoid",             # 혐오 : 피하다
+            "surprise": "gasp",             # 놀람 : 감탄하며 숨을 들이쉼
+            "neutral": "idle",              # 중립 : 아무것도 하지 않음
 
-                        # 기본 정서 (부정) - 느림
-                        "sadness": "sit_down",      # 슬픔 : 주저 앉는다
-                        "anger": "shout",           # 분노 : 소리치다.
-                        "anxiety": "look_around",   # 불안 : 주위를 살핀다
-                        "disgust": "avoid",         # 혐오 : 피하다
-                        "fear": "run_away",         # 공포 : 도망치다
-                        "regret": "look_down",      # 후회 : 아래를 보다
-                        "frustration": "sigh",      # 좌절 : 한숨 쉬다
+            # Social (사회적 감정)
+            "gratitude": "thank",           # 감사 : 감사하다
+            "shame": "hide_face",           # 수치심 : 얼굴을 감추다
+            "guilt": "apologize",           # 죄책감 : 미안하다고 말함
+            "pride": "show_off",            # 자부심 : 자랑하다
+            "jealousy": "glare",            # 질투 : 노려보다
+            "compassion": "console",        # 연민/동정 : 위로하다
+            "love": "embrace",              # 사랑/애정 : 포옹하다
+            "admiration": "cheer",          # 존경/감탄 : 환호하다
+            "empathy": "listen_carefully",  # 공감 : 집중하다
+            "awe": "gasp",                  # 경외심 : 감탄하며 숨을 들이쉼
+            "attachment": "hold_hands",     # 애착 : 소유하다
+            "comfort": "pat",               # 위로 추구 : 토닥거리다
 
-                        # 사회적 감정
-                        "jealousy": "glare",        # 질투 : 노려보다
-                        "shame": "hide_face",       # 수치심 : 얼굴을 감추다
-                        "guilt": "apologize",       # 죄책감 : 미안하다고 말함
-                        "compassion": "console",    # 동정심 : 위로하는 행동
-                        "awe": "gasp",              # 경외심 : 감탄하며 숨을 들이쉼
-                        "empathy": "listen_carefully", # 공감 : 공감하며 집중해서 경청
+            # Cognitive (인지적 상태)
+            "anticipation": "prepare",      # 기대 : 준비하다
+            "curiosity": "inspect",         # 호기심 : 살펴보다
+            "confusion": "scratch_head",    # 혼란 : 머리를 긁다
+            "interest": "lean_forward",     # 흥미 : 집중하다
+            "engagement": "focus",          # 몰입 : 집중하다
+            "boredom": "idle",              # 지루함 : 아무것도 하지 않음
+            "relief": "exhale",             # 안도 : 숨을 내쉬다
+            "anxiety": "fidget",            # 불안/긴장 : 안절부절 못하다
+            "calm": "relax",                # 평온 : 진정하다
+            "skepticism": "raise_eyebrow",  # 회의 : 눈썹을 올리다
 
-                        # 인지적 상태
-                        "confusion": "scratch_head",# 혼란 : 머리를 긁적이다
-                        "nervousness": "fidget",    # 긴장 : 불안해서 몸을 계속 움직임
-                        "apathy": "idle",           # 무관심 : 아무것도 하지 않음
-                        "excitement": "move_fast",  # 흥분 : 빠르게 움직이다
-                        "immersion": "focus",       # 몰입 : 집중하는 모습
-                        "skepticism": "raise_eyebrow", # 회의 : 의심스러운 듯 눈썹을 찌푸림
+            # Complex (복합 감정)
+            "nostalgia": "stare_into_distance",     # 향수
+            "bittersweet": "smile_then_look_down",  # 달콤쌉싸름함
+            "schadenfreude": "smirk",               # 남의 불행에서 느끼는 기쁨
+            "hope": "brighten_up",                  # 희망
+            "resentment": "scowl",                  # 분개
+            "anticipatory_joy": "rub_hands",        # 기대 속의 기쁨
+            "regret": "look_down",                  # 후회
+            "rumination": "mutter_to_self",         # 반추
+            "groundedness": "steady_posture",       # 안정감
         }
 
-    def decide_sequence(self, composite_emotions):
+        # Layer 우선 순위 / weight 설정 (튜닝 가능)
+        self.layer_priority = ["core", "social", "cognitive", "complex"]
+        self.layer_weights = {
+            "core" : 1.0,
+            "social" : 0.8,
+            "cognitive" : 0.6,
+            "complex" : 0.4,
+        }
+    
+    def get_layer_dominant_emotions(self, buffer):
         """
-        복합 감정 상태(composite_emotions: [(emotions, score), ...])에 따른 행동 시퀀스 결정
+        layer별 dominant emotion 계산
+        """
+        layer_emotions = {layer: [] for layer in self.layer_priority}
+        for emo, val in buffer.items():
+            if val > 0:
+                layer = EMOTION_CATEGORY_MAP.get(emo)
+                if layer:
+                    layer_emotions[layer].append((emo, val))
+
+        # 각 layer에서 가장 강한 감정 추출
+        layer_dominant = {}
+        for layer, emos in layer_emotions.items():
+            if emos:
+                dominant_emo = max(emos, key=lambda x: x[1])
+                layer_dominant[layer] = dominant_emo
+            
+        return layer_dominant
+    
+    def decide_layered_sequence(self, layer_dominant_emotions):
+        """
+        layer priority + weight 기반 시퀀스 생성
         """
         sequence = []
-        for emo, score in composite_emotions:
-            action = self.mapping.get(emo)
-            if action:
-                sequence.append((action, score))    # (행동, 감정 강도 형태로 저장)
+        for layer in self.layer_priority:
+            if layer in layer_dominant_emotions:
+                emo, score = layer_dominant_emotions[layer]
+                weighted_score = round(score * self.layer_weights[layer], 2)
+                action = self.mapping.get(emo)
+                if action:
+                    sequence.append((action, weighted_score))
         return sequence
     
-    def perform_sequence(self, name, job, composite_emotion):
+    def perform_sequence(self, name, job, emotion_buffer, return_trace=False):
         """
-        행동 시퀀스를 텍스트로 구성하여 출력
+        Layer-aware Behavior 시퀀스 구성 + Behavior Trace 반환
         """
-        sequence = self.decide_sequence(composite_emotion)
+        layer_dominant_emotions = self.get_layer_dominant_emotions(emotion_buffer)
+        sequence = self.decide_layered_sequence(layer_dominant_emotions)
         if not sequence:
-            return f"{name}은(는) 특별한 행동을 하지 않습니다."
+            behavior_output = f"{name}은(는) 특별한 행동을 하지 않습니다."
+            if return_trace:
+                return behavior_output, "특별한 행동 없음"
+            else:
+                return behavior_output
         
         # 행동 텍스트 템플릿
         behavior_lines = {
-            "jump": f"기뻐서 깡충 뜁니다.",
-            "shout": f"화가 나서 소리를 지릅니다!",
-            "run_away": f"무서워 도망갑니다!",
-            "sit_down": f"슬퍼서 주저앉습니다....",
-            "wave": f"손을 흔듭니다.",
-            "sigh": f"한숨을 쉽니다...",
-            "thank": f"감사한 마음을 표현합니다.",
-            "console": f"상대방을 따듯하게 위로합니다.",
-            "avoid": f"뒤로 물러서 피하려 합니다.",
+            # Core
+            "jump": "기뻐서 깡충 뜁니다.",
+            "sit_down": "슬퍼서 주저앉습니다....",
+            "shout": "화가 나서 소리를 지릅니다!",
+            "run_away": "무서워 도망갑니다!",
+            "avoid": "뒤로 물러서 피하려 합니다.",
+            "gasp": "깜짝 놀랍니다.",
+            "idle": "가만히 있습니다.",
+
+            # Social
+            "thank": "감사한 마음을 표현합니다.",
+            "hide_face": "수치심에 얼굴을 가립니다.",
+            "apologize": "미안하다고 말합니다.",
             "show_off": "자랑스러운 모습을 보여줍니다.",
-            # 나머지는 기본 fallback 사용
+            "glare": "상대를 노려봅니다.",
+            "console": "상대방을 따뜻하게 위로합니다.",
+            "embrace": "상대를 포옹합니다.",
+            "cheer": "감탄하며 응원합니다.",
+            "listen_carefully": "상대의 말을 집중해서 듣습니다.",
+            "hold_hands": "손을 잡습니다.",
+            "pat": "가볍게 등을 두드려 위로합니다.",
+
+            # Cognitive
+            "prepare": "무언가를 준비합니다.",
+            "inspect": "유심히 관찰합니다.",
+            "scratch_head": "머리를 긁적입니다.",
+            "lean_forward": "앞으로 숙이며 집중합니다.",
+            "focus": "몰입하여 집중합니다.",
+            "exhale": "안도하며 숨을 쉽니다.",
+            "fidget": "불안하게 몸을 움직입니다.",
+            "relax": "평온하게 휴식합니다.",
+            "raise_eyebrow": "의심스럽게 눈썹을 치켜뜹니다.",
+
+            # Complex
+            "stare_into_distance": "먼 곳을 바라보며 회상에 잠깁니다.",
+            "smile_then_look_down": "미소를 짓다가 고개를 숙입니다.",
+            "smirk": "비웃는 표정을 짓습니다.",
+            "brighten_up": "기대감에 눈빛이 빛납니다.",
+            "scowl": "인상을 찌푸립니다.",
+            "rub_hands": "들뜬 마음에 손을 비빕니다.",
+            "look_down": "고개를 숙이며 후회합니다.",
+            "mutter_to_self": "혼잣말을 중얼거립니다.",
+            "steady_posture": "안정된 자세를 유지합니다.",
         }
 
         # 행동 문장 생성
         lines = []
+        trace_lines = []
         for action, score in sequence:
             msg = behavior_lines.get(action, f"{action} 행동을 합니다.")
             lines.append(f"({round(score,1)}) {msg}")
+            trace_lines.append(f"{action}({round(score, 1)})")
 
         # 직업 라인 추가
         job_line = {
@@ -85,5 +170,11 @@ class BehaviorManager:
             "blacksmith": "대장간 불도 지펴야죠.",
         }.get(job, "오늘도 바쁜 하루네요.")
 
+        behavior_output = f"{name} 행동 시퀀스: \n" + "\n".join(lines) + f"\n{job_line}"
+        behavior_trace = ", ".join(trace_lines)
+
         # 최종 출력 문장
-        return f"{name} 행동 시퀀스: \n" + "\n".join(lines) + f"\n{job_line}"
+        if return_trace:
+            return behavior_output, behavior_trace
+        else:
+            return behavior_output

npc_social_network/npc/npc_emotion.py

@@ -1,60 +1,83 @@
 # 감정 상태, 감정 업데이트, decay 처리
 # portfolio/npc_social_network/npc/npc_emotion.py
-from .emotion_config import AFFECT_EMOTIONS, SOCIAL_EMOTIONS, COGNITIVE_STATES
+from .emotion_config import EMOTION_LIST, EMOTION_DECAY_RATE, EMOTION_CATEGORY_MAP
 
 class EmotionManager:
-    def __init__(self, emotion_state, decay_rate, personality = None):
-        # 고차원 감정 상태 (GoEmotions 기반)
-        self.emotion_state = emotion_state
+    def __init__(self, decay_rate, personality = None):
+        # 내부: float 감정 수치 관리용 버퍼
+        self._emotion_buffer = {emo: 0.0 for emo in EMOTION_LIST}
         # 감정별 회복 속도 (ms 단위가 아닌 단위당 감소 속도)
         self.decay_rate = decay_rate
-        # 내부: float 감정 수치 관리용 버퍼
-        self._emotion_buffer = {emo: 0.0 for cat in emotion_state.values() for emo in cat}
         self.personality = personality or {}
 
-    # 특정 감정을 감정 상태에 반영 (카테고리 기반)
-    def update_emotion(self, emotion: str, strength: float = 1.0):
+    def update_emotion(self, emotion: str, strength: float = 1.0, context: str = "general"):
+        """
+        특정 감정을 감정 상태에 반영 (카테고리 기반)
+        """
         if emotion not in self._emotion_buffer:
             print(f"[경고] '{emotion}'은(는) 정의된 감정이 아닙니다.")
             return
         
         # 개성 계수 반영
-        multiplier = 1.0
-        if emotion in AFFECT_EMOTIONS["positive"]:
-            multiplier *= self.personality.get("positive_bias", 1)
-        elif emotion in AFFECT_EMOTIONS["negative"]:
-            multiplier *= self.personality.get("negative_bias", 1)
+        multiplier = self.personality.get("sensitive", 1.0)
 
-        # 개성 계수 반영
-        multiplier *= self.personality.get("sensitive", 1)
+        category = EMOTION_CATEGORY_MAP.get(emotion, None)
+        if category == "core":
+            multiplier *= self.personality.get("affect_bias", 1.0)
+        elif category == "social":
+            # 사회적 감정은 social context에서만 반영
+            if context != "social":
+                return # 무시
+            multiplier *= self.personality.get("social_bias", 1.0)
+        elif category == "cognitive":
+            multiplier *= self.personality.get("cognitive_bias", 1.0)
+        elif category == "complex":
+            multiplier *= self.personality.get("complex_bias", 1.0)
 
+        # 감정 반영
         self._emotion_buffer[emotion] += strength * multiplier
-        for category in self.emotion_state:
-            if emotion in self.emotion_state[category]:
-                self.emotion_state[category][emotion] = int(self._emotion_buffer[emotion])
-                break
 
-
-    # 시간이 지남에 따라 모든 감정이 서서히 감소
     def decay_emotion(self):
-        for emotion, value in self._emotion_buffer.items():
+        """
+        시간이 지남에 따라 모든 감정이 서서히 감소
+        """
+        for emotion in EMOTION_LIST:
             rate = self.decay_rate.get(emotion, 0.5)
-            modifier = 1.0 - self.personality.get("stoic", 0)
-            self._emotion_buffer[emotion] = max(0.0, value - rate * modifier)
-
-        for category in self.emotion_state:
-            for emotion in self.emotion_state[category]:
-                self.emotion_state[category][emotion] = int(self._emotion_buffer[emotion])
+            modifier = 1.0 - self.personality.get("stoic", 0.0)
+            self._emotion_buffer[emotion] = max(0.0, self._emotion_buffer[emotion] - rate * modifier)
 
-    # 정수 기반 출력용 감정 상태 반환
     def get_state(self):
-        return {cat: {emo: int(self._emotion_buffer[emo]) for emo in emos} for cat, emos in self.emotion_state.items()}
+        """
+        감정 상태 반환 (출력용, 정수로 변환)
+        """
+        return {emo: int(self._emotion_buffer[emo]) for emo in EMOTION_LIST}
     
-    # 현재 가장 강한 감정 반환 (전체 감정 중 최댓값 1개)
-    def get_dominant_emotion(self):
-        if not self._emotion_buffer:
-            return "neutral"
-        return max(self._emotion_buffer.items(), key=lambda x: x[1])[0]
+    def get_dominant_emotion(self, layer: str = None):
+        """
+        현재 가장 강한 감정 반환 (전체 감정 중 최대값 1개)
+        """
+        if layer:
+            # 특정 layer 대상
+            layer_emotions = [emo for emo, cat in EMOTION_CATEGORY_MAP.items() if cat == layer]
+            if not layer_emotions:
+                return None
+            dominant_emo, score = max(
+                ((emo, self._emotion_buffer[emo]) for emo in layer_emotions),
+                key=lambda x: x[1],
+                default=(None, 0.0)
+            )
+            if score == 0.0:
+                return None
+            return dominant_emo
+        else:
+            # 전체 대상
+            dominant_emo, score = max(self._emotion_buffer.items(), key=lambda x:x[1])
+            if score == 0.0:
+                return None
+            return dominant_emo
     
     def get_buffer(self):
+        """
+        emotion_buffer 복사본 반환
+        """
         return self._emotion_buffer.copy()

npc_social_network/npc/npc_memory.py

@@ -10,13 +10,16 @@ class Memory:
     - importance: 중요도 (1~10)
     - emotion: 감정 태그 (기쁨, 슬픔, 분노, 중립 등)
     - is_long_term: 장기 기억 여부
+    - behavior_trace: 기억을 통한 행동 추적
     """
-    def __init__(self, content: str, timestamp: datetime = None, importance: int = 1, emotion: str = "중립"):
+    def __init__(self, content: str, timestamp: datetime = None,
+                 importance: int = 1, emotion: str = "neutral", behavior_trace: str = None):
         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
 
 
 class MemoryStore: