몸(행동)과 관련된 내용 제거한 리팩토링 시작

npc_social_network/README.txt

@@ -19,21 +19,11 @@ LLM과 embedding 기반 기억 시스템을 통해 정교한 NPC 반응을 구
 portfolio/
 ├── app.py                         # Flask 진입점
 ├── requirements.txt
-├── run_npc_interactions.py
 ├── test.ipynb
 └── npc_social_network/
     ├── README.txt
     ├── routes/
     │   └── npc_route.py              # 웹 라우트 (API)
-    ├── maps/
-    │   ├── villages/town_hall.py     # Pygame 메인 실행
-    │   ├── engine/game_engine.py     # 게임 루프, 감정 HUD
-    │   └── manager/
-    │       ├── tile.py               # Tile 클래스
-    │       ├── building.py           # 건물 클래스
-    │       ├── image_loader.py       # 이미지 로딩
-    │       ├── image_registry.py     # 이미지 경로 사전
-    │       └── village_map.py        # Village 전체 구성
     ├── npc/
     │   ├── npc_base.py               # NPC 본체 (감정/기억/관계 포함)
     │   ├── npc_manager.py            # NPC 리스트 관리

npc_social_network/{maps/manager → manager}/simulation_manager.py

@@ -1,4 +1,4 @@
-# portfolio/npc_social_network/map/manager/simulation_manager.py
+# portfolio/npc_social_network/manager/simulation_manager.py
 import pickle
 import os
 from npc_social_network.npc.npc_manager import NPCManager

npc_social_network/maps/engine/game_engine.py

@@ -1,206 +0,0 @@
-# portfolio/npc_social_network/maps/engine/game_engine.py
-# 게임 루프 및 이벤트 처리
-import pygame
-from pygame import Rect
-import sys
-import random
-from datetime import datetime, timedelta
-from npc_social_network.maps.manager.image_loader import ImageLoader
-from npc_social_network.maps.manager.village_map import VillageMap
-from npc_social_network.npc.npc_manager import NPCManager
-
-
-class GameEngine:
-    """
-    게임 루프, 이벤트 처리, 시각화 담당
-    """
-    def __init__(self, screen, font, village: VillageMap, time_states: list, npc_manager: NPCManager):
-        self.screen = screen
-        self.font = font
-        # emotion HUD용 작은 글자 font 추가
-        self.emotion_font = pygame.font.SysFont("malgungothic", 14)
-        self.village = village
-        self.time_states = time_states
-        self.npc_manager = npc_manager
-        self.image_loader = village.image_loader 
-
-        self.current_time_index = 0
-        self.frame_count = 0
-        self.frame_per_time_state = 200     # 기존: 시간 상태 전환 프레임
-        self.selected_npc = None            # 선택된 NPC 상태 기본 필드
-
-        # 감정 바 색상 테이블 (수정 필요)
-        self.emotion_colors = {
-            "joy": (255, 215, 0), "gratitude": (173, 216, 230),
-            "anger": (255, 69, 0), "fear": (138, 43, 226),
-            "sadness": (70, 130, 180), "love": (255, 105, 180),
-            "interest": (0, 255, 127), "relief": (60, 179, 113),
-        }
-        # 관계 바 색상 테이블
-        self.relationship_colors = {
-            "best friend": (255, 182, 193), "friend": (144, 238, 144),
-            "acquaintance": (240, 230, 140), "stranger": (211, 211, 211),
-            "nuisance": (255, 160, 122), "rival": (255, 99, 71),
-            "enemy": (220, 20, 60),
-        }
-
-
-        # 실제 시간 흐름 시뮬레이션용
-        self.current_time = datetime.now()        # 현재 시뮬레이션 시간
-        self.time_step = timedelta(minutes=1)         # 1틱 = 1분
-
-    def draw(self):
-        self.village.draw(self.screen)  # 마을 전체를 그림
-
-        # 상단 시간 텍스트 출력
-        time_state_text = self.time_states[self.current_time_index]
-        time_text = self.font.render(
-            f"현재 시간: {time_state_text} | {self.current_time.strftime('%H:%M')}",
-            True, (0, 0, 0)
-        )
-        self.screen.blit(time_text, (10, 10))
-
-        # 감정 상태 HUD 렌더링
-        if self.selected_npc:
-            self.draw_emotion_hud()
-
-    def draw_emotion_hud(self):
-        """
-        감정 상태와 함께 관꼐 상태(유형, 점수)를 HUD에 표시
-        """
-        npc = self.selected_npc
-        top_emotions = npc.get_top_emotions(top_n=5)
-
-        # 플레이어와의 관계 정보 가져오기
-        player_profile = npc.relationships._get_or_create_profile("플레이어")
-        relationship_type = player_profile.type
-        relationship_score = player_profile.score
-
-        # HUD 레이아웃 설정
-        hud_height = 180   # 원하는 높이
-        margin_right = 20  # 오른쪽 여백
-        margin_bottom = 20 # 아래쪽 여백 (화면 아래 띄우고 싶으면 사용)
-
-        hud_width = self.screen.get_width() * 0.45  # 화면 절반 너비
-        hud_rect = Rect(
-            self.screen.get_width() - hud_width - margin_right,
-            self.screen.get_height() - hud_height - margin_bottom,
-            hud_width,
-            hud_height
-        )
-        # 반투명 배경
-        s = pygame.Surface((hud_width, hud_height), pygame.SRCALPHA)
-        s.fill((30, 30, 30, 200))
-        self.screen.blit(s, (hud_rect.x, hud_rect.y))
-
-        padding_x = 20  # 오른쪽에서 얼마나 띄울지
-        padding_y = 10  # 위에서 얼마나 띄울지
-        spacing_y = 20 # 감정 간 간격
-        label_bar_gap = 100 # label과 bar 사이 간격
-        title_gap = 30  # 제목과 감정 표시 사이 간격
-        bar_width_max = hud_width - 2 * padding_x - label_bar_gap
-        bar_height = 18
-
-        # NPC 이름
-        self.screen.blit(
-            self.font.render(f"{npc.name} 내면", True, (255, 255, 255)),
-            (hud_rect.x + padding_x, hud_rect.y + padding_y)
-        )
-
-        # 감정 표시
-        for i, (emotion_name, value) in enumerate(top_emotions):
-            y = hud_rect.y + padding_y + title_gap + i * spacing_y
-
-            text_surface = self.emotion_font.render(f"{emotion_name} ({value:.1f})", True, (255, 255, 255))
-            self.screen.blit(text_surface, (hud_rect.x + padding_x, y))
-
-            # bar background
-            bar_bg_rect = Rect(hud_rect.x + padding_x + label_bar_gap, y + 3, bar_width_max, bar_height)
-            pygame.draw.rect(self.screen, (50, 50, 50), bar_bg_rect)
-
-            # bar fill
-            color = self.emotion_colors.get(emotion_name, (100, 200, 255))
-            # color 값이 유효한 튜플인지 확인
-            if not (isinstance(color, tuple) and len(color) == 3 and all(isinstance(c, int) for c in color)):
-                print(f"[경고] 잘못된 color 값 감지: {emotion_name} → {color}, 디폴트 색상 사용")
-                color = (100, 200, 255)
-
-            bar_fill_width = int((value / 10) * bar_width_max)
-            bar_fill_rect = Rect(hud_rect.x + padding_x + label_bar_gap, y + 3, bar_fill_width, bar_height)
-            pygame.draw.rect(self.screen, color, bar_fill_rect)
-
-        # 관계 상태 표시
-        relation_y = hud_rect.y + padding_y + title_gap + len(top_emotions) * spacing_y
-        relation_color = self.relationship_colors.get(relationship_type, (200, 200, 200))
-        relation_text = f"플레이어와의 관계: {relationship_type} ({relationship_score:.1f})"
-        relation_surface = self.emotion_font.render(relation_text, True, relation_color)
-        self.screen.blit(relation_surface, (hud_rect.x + padding_x, relation_y))
-
-    def update(self):
-        """
-        게임의 모든 상태를 업데이트 (시간, NPC 행동, 상호작용 등)
-        """
-        self.frame_count += 1
-        time_state_text = self.time_states[self.current_time_index]
-
-        # 1) 시간 상태(아침/점심 등) 순환 유지
-        if self.frame_count % self.frame_per_time_state == 0:
-            self.current_time_index = (self.current_time_index + 1) % len(self.time_states)
-
-        # 2) 실제 시간 경과
-        self.current_time += self.time_step
-
-        # NPC 행동/기억 업데이트
-        if self.frame_count % 20 == 0:
-            self.village.update_npcs(self.time_states[self.current_time_index])
-
-        # NPC 기억 승격 판단
-        if self.frame_count % 60 == 0:  # 60 프레임마다 약 3초 기준
-            for npc in self.npc_manager.all():
-                npc.memory_store.promote_memories(time_threshold_minutes=60)
-
-        # 일정 프레임마다 모든 NPC의 자율 행동 업데이트
-        if self.frame_count % 120 == 0: # 약 12초에 한 번
-            # NPC 간 상호작용 시작
-            if random.random() < 0.3:    # 30% 확률
-                self.npc_manager.initiate_npc_to_npc_interaction(time_context=time_state_text)
-
-            for npc in self.npc_manager.all():
-                # 주기적으로 관계 요약 업데이트 시도
-                if random.random() < 0.1:
-                    target_to_summarize = self.npc_manager.get_random_npc(exclude=npc)
-                    if target_to_summarize:
-                        npc.relationships.summarize_relationship(target_to_summarize.name)
-                # 자율 행동 실행
-                npc.update_autonomous_behavior(time_context=time_state_text)
-
-        # 매우 낮은 확률로 NPC가 상징 기억을 생성하도록 함
-        if self.frame_count % 500 == 0: # 약 50초에 한 번, 낮은 확률로
-            if random.random() < 0.05: # 5% 확률
-                random_npc = self.npc_manager.get_random_npc()
-                if random_npc:
-                    random_npc.create_symbolic_memory()
-
-    def handle_click(self, pos):
-        mx, my = pos
-        tile_x = mx // self.village.tile_size
-        tile_y = my // self.village.tile_size
-        npc = self.village.npc_manager.get_npc_at(tile_x, tile_y)
-        if npc:
-            time_state_text = self.time_states[self.current_time_index]
-            print(f"\n👤 {npc.name} ({npc.job})")
-            print(f" - 위치: ({tile_x}, {tile_y})")
-            print(f" - 대화: {npc.generate_dialogue(user_input='', use_llm=False, time_context=time_state_text)}")
-            print(f" - 기억: {npc.recall()}")
-            self.set_selected_npc(npc)
-
-    def set_selected_npc(self, npc):
-        self.selected_npc = npc
-        print(f"[HUD] {npc.name} 선택됨 → 감정 상태 표시 시작")
-
-    def clear_selected_npc(self):
-        """
-        ESC 키로 Selected_npc 해제 메서드
-        """
-        print("[HUD] 감정 상태 표시 해제됨")
-        self.selected_npc = None

npc_social_network/maps/manager/building.py

@@ -1,11 +0,0 @@
-# portfolio/npc_social_network/maps/manager/building.py
-# 건물 클래스 정의
-class Building:
-    def __init__(self, x, y, b_type, image):
-        self.x = x
-        self.y = y
-        self.type = b_type
-        self.image = image
-
-    def draw(self, screen, tile_size):
-        screen.blit(self.image, (self.x * tile_size, self.y * tile_size))

npc_social_network/maps/manager/image_loader.py

@@ -1,27 +0,0 @@
-# portfolio/npc_social_network/maps/manager/image_loader.py
-# 이미지 로더 클래스
-import os
-import pygame
-from npc_social_network.maps.manager.image_registry import IMAGE_PATHS
-
-class ImageLoader:
-    def __init__(self, tile_size):
-        self.tile_size = tile_size
-        self.cache = {}
-
-        # 현재 파일 기준 static/images/tiles까지의 절대 경로 설정
-        current_dir = os.path.dirname(os.path.abspath(__file__))  # .../maps/manager
-        self.base_path = os.path.abspath(
-            os.path.join(current_dir, '..', '..', 'static', 'images', 'tiles')
-        )
-
-    def load(self, category, key):
-        path = IMAGE_PATHS[category][key]
-        if path in self.cache:
-            return self.cache[path]
-        
-        full_path = os.path.join(self.base_path, path) # 절대 경로로 이미지 위치 설정
-        image = pygame.image.load(full_path)
-        image = pygame.transform.scale(image, (self.tile_size, self.tile_size))
-        self.cache[path] = image
-        return image

npc_social_network/maps/manager/image_registry.py

@@ -1,25 +0,0 @@
-# portfolio/npc_social_network/maps/manager/image_registry.py
-# 모든 이미지 경로 중앙관리
-
-IMAGE_PATHS = {
-    "terrain": {
-        "grass": "terrain/tile_grass.png",
-        "dirt": "terrain/tile_dirt.png",
-        "stone": "terrain/tile_stone.png",
-        "water": "terrain/tile_water.png",
-        "pool" : "terrain/tile_pool.png",
-    },
-    "building": {
-        "house": "building/build_house.png",
-        "temple": "building/build_temple.png",
-        "market": "building/build_market.png",
-    },
-    "plant": {
-        "tree": "plant/plant_tree.png",
-        "wheat": "plant/plant_wheat.png",
-        "raspberry": "plant/plant_raspberry.png",
-    },
-    "npc": {
-        "default": "npc/npc.png",
-    }
-}

npc_social_network/maps/manager/tile.py

@@ -1,11 +0,0 @@
-# portfolio/npc_social_network/maps/manager/tile.py
-# 타일 클래스 정의
-class Tile:
-    def __init__(self, x, y, tile_type, image):
-        self.x = x
-        self.y = y
-        self.type = tile_type
-        self.image = image
-
-    def draw(self, screen, tile_size):
-        screen.blit(self.image, (self.x * tile_size, self.y * tile_size))

npc_social_network/maps/manager/village_map.py

@@ -1,59 +0,0 @@
-# portfolio/npc_social_network/maps/manager/village_map.py
-# 마을 전체 관리 클래스
-
-from npc_social_network.npc.npc_base import NPC
-from npc_social_network.npc.npc_manager import NPCManager
-
-class Building:
-    def __init__(self, x, y, b_type, image):
-        self.x = x
-        self.y = y
-        self.type = b_type
-        self.image = image
-    
-    def draw(self, screen, tile_size):
-        screen.blit(self.image, (self.x * tile_size, self.y * tile_size))
-
-class VillageMap:
-    def __init__(self, image_loader, tile_size, grid_width, grid_height,  npc_manager: NPCManager):
-        self.image_loader = image_loader
-        self.tile_size = tile_size
-        self.grid_width = grid_width
-        self.grid_height = grid_height
-        self.tiles = []
-        self.buildings = []
-        self.npc_manager = npc_manager
-
-    def generate(self):
-        import random
-
-        terrain_keys = list(self.image_loader.cache.keys()) or ["grass", "dirt", "stone"]
-        
-        for y in range(self.grid_height):
-            for x in range(self.grid_width):
-               terrain = random.choice(["grass", "dirt", "stone"])
-               image = self.image_loader.load("terrain", terrain)
-               self.tiles.append((x, y, image))
-
-        # 건물 초기 세팅값
-        self.buildings = [
-            Building(2, 3, "house", self.image_loader.load("building","house")),
-            Building(5, 5, "market", self.image_loader.load("building","market")),
-            Building(10, 3, "wheat", self.image_loader.load("plant", "wheat")),
-            Building(8, 8, "temple", self.image_loader.load("building", "temple", )),
-        ]
-
-    def draw(self, screen):
-        for x, y, image in self.tiles:
-            screen.blit(image, (x * self.tile_size, y * self.tile_size))
-        for b in self.buildings:
-            b.draw(screen, self.tile_size)
-        self.npc_manager.draw_all(screen, self.tile_size, self.image_loader)
-
-    def update_npcs(self, time_state):
-        self.npc_manager.move_all()
-        for npc in self.npc_manager.all():
-            x, y = npc.get_position()
-            for b in self. buildings:
-                if (b.x, b.y) == (x, y):
-                    print(f"{time_state} - {npc.name}이(가) {b.type}에 도착했습니다.")

npc_social_network/maps/villages/town_hall.py

@@ -1,84 +0,0 @@
-# portfolio/npc_social_network/maps/villages/town_hall.py
-# 메인 실행 파일
-import pygame
-import sys
-from npc_social_network.scenarios.scenario_setup import setup_initial_scenario
-from ..manager.simulation_manager import save_simulation, load_simulation
-from npc_social_network.maps.manager.image_loader import ImageLoader
-from npc_social_network.maps.manager.village_map import VillageMap
-from npc_social_network.maps.engine.game_engine import GameEngine
-from npc_social_network.npc.npc_manager import NPCManager
-from npc_social_network.npc.npc_base import NPC
-
-def run_town_hall_simulation():
-
-    # 초기 설정
-    pygame.init()
-
-    tile_size = 32
-    width, height = 20, 20
-    screen = pygame.display.set_mode((width * tile_size, height * tile_size))
-    pygame.display.set_caption("town_hall")
-
-    # 캐릭터가 움직이는 일정 시간
-    clock = pygame.time.Clock()
-    font = pygame.font.SysFont("malgungothic", 20) # 한글 출력용
-
-    # 저장/불러오기
-    npc_manager = load_simulation() # 저장된 상태를 불러오기 시도
-
-    image_loader = ImageLoader(tile_size)
-
-    if npc_manager is None:
-        # 저장된 파일이 없으면 새로운 시나리오 시작
-        npc_manager = setup_initial_scenario(image_loader)
-
-    # 로딩
-    village = VillageMap(image_loader, tile_size, width, height, npc_manager)
-    village.generate()
-
-    if len(npc_manager.all()) == 0:
-        # 불러온 데이터가 비어있거나, 새로 시작하는 경우
-        village.generate()
-        print("새로운 NPC들을 생성했습니다.")
-
-    # 게임 엔진 초기 세팅
-    engine = GameEngine(screen, font, village, ["아침", "점심", "저녁", "밤"], npc_manager)
-
-    # pygame 루프
-    runnig = True
-    while runnig:
-        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
-                running = False
-            elif event.type == pygame.KEYDOWN:
-                if event.key == pygame.K_s: # 'S' 키를 누르면 저장
-                    save_simulation(npc_manager)
-                elif event.key == pygame.K_l: # 'L' 키를 누르면 불러오기
-                    loaded_manager = load_simulation()
-                    if loaded_manager:
-                        npc_manager = loaded_manager
-                        # 불러온 데이터로 엔진 재설정
-                        village.npc_manager = npc_manager
-                        engine.npc_manager = npc_manager
-                        engine.selected_npc = None # 선택 초기화
-                        print("시뮬레이션을 새로고침했습니다.")
-
-                elif event.key == pygame.K_ESCAPE:
-                    engine.clear_selected_npc()     # ESC로 선택 해제
-            elif event.type == pygame.MOUSEBUTTONDOWN:
-                engine.handle_click(pygame.mouse.get_pos())     # 마우스 클릭으로 NPC 선택
-
-        screen.fill((255, 255, 255))
-        engine.update()
-        engine.draw()
-        pygame.display.update()
-        clock.tick(10) # 초당 10프레임
-
-    # 종료 전에 최종 상태 저장
-    save_simulation(npc_manager)
-    pygame.quit()
-    sys.exit()
-
-if __name__ == "__main__":
-    run_town_hall_simulation()

npc_social_network/npc/npc_base.py

@@ -73,12 +73,9 @@ class NPC:
     NPC 클래스
     NPC에 대한 기본 정보를 객체화
     """
-    def __init__(self, name, job, path, image_identifier, personality=None):
+    def __init__(self, name: str, job: str, personality: Optional[dict]=None):
         self.name = name
         self.job = job
-        self.path = path
-        self.image_identifier = image_identifier
-        self.current_index = 0
 
         # npc 기억
         self.memory_store = MemoryStore()
@@ -87,45 +84,37 @@ class NPC:
         self.personality = PersonalityManager(personality)
         self.relationships = RelationshipManager(self)
         self.emotion = EmotionManager(EMOTION_DECAY_RATE, self.personality)
-
         # 행동 관리자
         self.behavior = BehaviorManager()
         self.planner = PlannerManager(self)
-
         # 내부: float 감정 수치 관리용 버퍼
         self._emotion_buffer = self.emotion.get_buffer()
+
         # baseline 감정 값 부여
         baseline_buffer = {}
         for emo in self._emotion_buffer:
             base_min = 0.05
             base_max = 0.3
             category = EMOTION_CATEGORY_MAP.get(emo, None)
-            bias = 1.0
-
-            if category == "core":
-                bias = self.personality.get("affect_bias", 1.0)
-            elif category == "social":
-                bias = self.personality.get("social_bias", 1.0)
-            elif category == "cognitive":
-                bias = self.personality.get("cognitive_bias", 1.0)
-            elif category == "complex":
-                bias = self.personality.get("complex_bias", 1.0)
-            else:
-                bias = self.personality.get("sensitive", 1.0)
+            bias_map = {
+                "core": "affect_bias", "social": "social_bias",
+                "cognitive": "cognitive_bias", "complex": "complex_bias"
+            }
+            bias = self.personality.get(bias_map.get(category, "sensitive"), 1.0)
 
             baseline_value = base_min + (base_max - base_min) * bias
             baseline_value *= self.personality.get("sensitive", 1.0)    # 전체 민감도 적용
 
             baseline_buffer[emo] = round(baseline_value, 3)
-            self._emotion_buffer[emo] = baseline_buffer[emo]    # emotion_buffer 초기 적용
 
         # baseline buffer를 EmotionManager에 등록
         self.emotion.set_baseline(baseline_buffer)
+        # emotion_buffer 초기화
+        self._emotion_buffer = self.emotion.get_buffer()
 
         # 프로필 지정 → 기본은 "stable", 나중에 NPC마다 다르게 부여
         profile_type = "stable"
         profile = PERSONALITY_PROFILE[profile_type]
-        
         # Personality 변화 속도 개별 설정
         self.personality_change_rate = {
             "sensitive": random.uniform(*profile["sensitive"]),
@@ -134,7 +123,7 @@ class NPC:
         }
 
         # Personality baseline 저장 (초기값 복사)
-        self.personality_baseline = copy.deepcopy(self.personality)
+        self.personality_baseline = copy.deepcopy(self.personality.traits)
 
         # 나이 추가 (0 ~ 80세 기본 랜덤 초기화 → 나중에 생성 시 age 지정 가능)
         self.age = random.randint(0, 80)
@@ -143,27 +132,6 @@ class NPC:
         self.personality_stage = None
         self.update_personality_stage()
 
-
-    def move(self):
-        """
-        이동
-        """
-        self.current_index = (self.current_index + 1) % len(self.path)
-
-    def get_position(self):
-        """
-        현재 위치 좌표 반환
-        """
-        return self.path[self.current_index]
-    
-    def draw(self, screen, tile_size, image_loader):
-        """
-        NPC 이미지 화면에 렌더링
-        """
-        image = image_loader.load(*self.image_identifier)
-        x, y = self.get_position()
-        screen.blit(image, (x * tile_size, y * tile_size))
-
     def generate_dialogue(self, user_input: str, time_context: str, target_npc: Optional["NPC"]=None, use_llm: bool=True) -> str:
         """
         플레이어 또는 NPC와 상호작용 시 사용되는 통합 대사 생성 함수
@@ -178,49 +146,31 @@ class NPC:
             if len(matched_memories) >= 3:
                 self.summarize_and_store_memories(matched_memories)
 
-            # 3. LLM 프롬프트 생성
-            prompt = build_npc_prompt(self, user_input, matched_memories, target_npc)
-
-            # 4. LLM 호출
+            # 3. LLM 프롬프트 생성 및 호출
+            prompt = build_npc_prompt(self, user_input, matched_memories, time_context, target_npc)
             npc_reply = query_llm_with_prompt(prompt)
 
-            # 5. 감정 추론
+            # 4. 자신의 응답에서 감정 추론 및 상태 업데이트
             emotion = query_llm_for_emotion(npc_reply)
             if emotion and emotion in EMOTION_LIST:
                 self.update_emotion(emotion, strength=2.0)
 
-            # 상호작용의 화자(interlocutor)를 명확히 함
+            # 5. 상호작용 기억 저장
             interlocutor_name = target_npc.name if target_npc else "플레이어"
+            memory_content = f"[{interlocutor_name}의 말] '{user_input}' → [나의 응답] '{npc_reply}'"
+            memory = self.remember(content=memory_content, importance=7, emotion=emotion, context_tags=[time_context])
 
-            # 6. Memory 저장
-            memory_content=""
-            if target_npc:
-                # NPC간 대화 기억
-                memory_content = f"[{interlocutor_name}의 말] '{user_input}' → [나의 응답] '{npc_reply}'"
-            else:
-                # 플레이어와의 기억
-                memory_content = f"[플레이어의 말] '{user_input}' → [나의 응답] '{npc_reply}'"
-
-            memory = self.remember(
-                content=memory_content,
-                importance=7,
-                emotion=emotion,
-                context_tags=[time_context]
-            )
-
-            # 7. 관계 반영 (플레이어나 다른 NPC)
+            # 6. 관계 상태 업데이트
             if emotion and emotion in EMOTION_RELATION_IMPACT:
                 self.relationships.update_relationship(interlocutor_name, emotion, strength=2.0, memory=memory)
-
             # NPC간 상호작용일 경우, 상대방의 프로필도 업데이트 (상대방의 평가)
             if target_npc:
                 target_emotion = query_llm_for_emotion(user_input)  # 내가 한 말에 대한 상대의 감정 추론
                 if target_emotion and target_emotion in EMOTION_RELATION_IMPACT:
                     target_npc.relationships.update_relationship(self.name, target_emotion, strength=2.0, memory=memory)
 
-            # 8. 성격 변화 반영
+            # 7. 성격 변화 반영
             self.update_personality()
-
             return npc_reply
 
         else:
@@ -288,80 +238,37 @@ class NPC:
         self.emotion.decay_emotion()
         self._emotion_buffer = self.emotion.get_buffer()
 
-    def recall(self):
+    def recall_all_memories(self) -> List[str]:
         """
         저장된 모든 기억(단기 + 장기)을 리스트로 반환
         """
         return [m.content for m in self.memory_store.get_all_memories()]
 
-    def get_composite_emotion_state(self, top_n: int = 3):
+    def get_composite_emotion_state(self, top_n: int = 3) -> List[tuple]:
         """
-        복합 감정 계산 (상위 N개 감정 반환)
+        현재 감정 상태 중 상위 N개를 반환
         """
         buffer = self.emotion.get_buffer()  # EmotionManager에서 최신 감정 상태 복사본 가져오기
         sorted_emotions = sorted(buffer.items(), key=lambda x: x[1], reverse=True)
-        composite = [(emo,round(score, 2)) for emo, score in sorted_emotions[:top_n] if score > 0]
+        composite = [(emo,round(score, 2)) for emo, score in sorted_emotions[:top_n] if score > 0.1]
         return composite # 예 [('fear', 2.0), ('anger'), 1.5]
     
-    def summarize_emotional_state(self):
+    def summarize_emotional_state(self) -> str:
         """
         감정 상태 요약 텍스트 생성
         """
         composite = self.get_composite_emotion_state()
         dominant = self.emotion.get_dominant_emotion()
-        return f"감정 평균 강도: {dominant} / 대표 감정: {composite if composite else '없음' }"
-
-    def _get_emotion_influence(self, emotion: str, positive: bool) -> float:
-        """
-        감정과 상호작용의 긍/부정 여부에 따른 관계 변화량 결정
-        """
-        base = 5.0 # 기본 영향력
-
-        # 감정 종류별 base 수정
-        if emotion in POSITIVE_RELATION_EMOTIONS:
-            base += 2.0
-            # 긍정 감정은 positive = True일 때만 +로 반영, positive = False일 경우 최소한으로 영향
-            return base if positive else 0.0
-        elif emotion in NEGATIVE_RELATION_EMOTIONS:
-            base += 3.0
-            # 부정 감정은 positive = False일 때만 -로 반영, positive = True일 경우 최소한으로 영향
-            return -base if not positive else 0.0
-        else:
-            # 정의되지 않은 감정 처리
-            return 0.0
+        if not dominant:
+            return "현재 특별한 감정 없이 평온한 상태입니다."
+        return f"현재 {dominant} 등의 감정을 느끼고 있습니다.\n(주요 감정: {composite if composite else '없음'})"
     
     def get_relationship_description(self, target_name: str) -> str:
         """
-        관계 점수 대신 SocialProfile의 요약을 반환하도록 수정
+        특정 대상과의 관계를 자연어로 반환
         """
         return self.relationships.get_relationship_summary(target_name)
 
-    def reflect_memory_on_relationship(self, other_npc_name:str):
-        """
-        기억이 관계에 미치는 영향 반영
-        """
-        # 최근 기억 + 최근 감정을 기반으로 관계 변화량 결정
-        memories = self.memory_store.get_all_memories()
-        dominant_emotion = self.emotion.get_dominant_emotion()
-
-        # 기준 설정
-        base_influence = 0.0
-        for mem in memories[-5:]:   # 최근 5개 기억 기준
-            if mem.importance >= 7: # 중요 기억만 반영
-                # 감정 성향에 따라 positive 결정 및 영향력 계산
-                # 중요 기억만 반영
-                is_positive = mem.emotion in POSITIVE_RELATION_EMOTIONS
-                delta = self._get_emotion_influence(mem.emotion, positive=is_positive)
-                base_influence += delta
-
-        # 현재 감정 상태 영향 추가 반영 (보조적 반영)
-        if dominant_emotion:
-            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 # 현재 감정은 보조적 영향
-
-        # 관계 갱신
-        self.relationships.update_relationship(other_npc_name, base_influence)
 
     def get_top_emotions(self, top_n=6):
         """
@@ -371,11 +278,10 @@ class NPC:
     
     def update_personality(self):
         """
-        Memory / Emotion 기반으로 Personality 변화 적용
+        경험에 따라 성격을 점진적으로 변화시킴
         - MemoryType 별 가중치 + EmotionInfluence 별 가중치 모두 반영
         """
         recent_memories = [m for m in self.memory_store.get_recent_memories(limit=10) if m.importance >= 5]
-
         if not recent_memories:
             return
 
@@ -461,7 +367,7 @@ class NPC:
         - 노년 NPC → 오래된 기억 더 강조
         """
         if self.personality_stage in [
-            "infancy_and_toddlerhood", "early_choldhood", "middle_childhood",
+            "infancy_and_toddlerhood", "early_childhood", "middle_childhood",
             "adolescence", "young_adulthood"
             ]:
             # 최근 기억 강조 → 오래된 기억 영향 약화
@@ -478,51 +384,15 @@ class NPC:
         """
         기억 리스트를 요약하고, NPC 장기 기억으로 저장
         """
-        if not memories:
-            return
-        
+        if not memories: return
         summary = summarize_memories(memories)
-
-        if "[LLM Error]" in summary:
-            print(f"[요약 실패] LLM 호출 중 에러가 발생하여 요약 기억을 저장하지 않습니다. 에러: {summary}")
-            return
-        
-        self.memory_store.add_memory(
-            Memory(content=summary, importance=9, emotion=self.emotion.get_dominant_emotion(), memory_type="Summary")
+        if "[LLM Error]" in summary: return
+        self.remember(
+            Memory(content=f"[요약된 기억] summary",
+                   importance=9,
+                   emotion=self.emotion.get_dominant_emotion(),
+                   memory_type="Summary")
         )
-        print(f"[요약 기억 저장됨] {summary}")
-
-    def reflect_memory_emotions_on_relationship(self, target_name: str, memory_limit: int=10):
-        """
-        대상과의 모든 상호작용 기억을 바탕으로 관꼐를 재평가하도록 개선
-        """
-        recent_memories = self.memory_store.get_recent_memories(limit=memory_limit)
-
-        for mem in recent_memories:
-            # 플레이어와의 관계를 평가할 때는, 다른 NPC 이름이 명시되지 않은 모든 대화 기억을 고려함
-            is_interaction_with_target = False
-            if target_name == "플레이어":
-                # 해당 기억이 플레이어와의 대화에서 비롯되었는지 확인 (단순 체크)
-                if "[입력]" in mem.content and "[응답]" in mem.content:
-                    is_interaction_with_target = True
-            elif target_name in mem.content:
-                is_interaction_with_target = True
-
-            if not is_interaction_with_target:
-                continue # 대상이 언급된 기억만 추출
-            
-            # 기억에 감정이 없거나, 관계에 영향을 주지 않는 감정이면 건너뜀
-            if not mem.emotion or mem.emotion not in EMOTION_RELATION_IMPACT:
-                continue
-
-            # 기억의 중요도를 기반으로 관계 변화 강도 결정 (1~10 -> 0.2~2.0)
-            strength = mem.importance / 5.0
-            print(f" - 기억 '{mem.content[:20]}...' (감정: {mem.emotion}, 중요도: {mem.importance}) -> 관계에 {strength:.1f}만큼의 강도로 영향을 줍니다.")
-            # 관계 업데이트 호출
-            self.relationships.update_relationship(target_name, mem.emotion, strength)
-
-        current_score = self.relationships.get_relationship(target_name)
-        print(f"[관계 업데이트 완료] {target_name}와의 최종 관계 점수: {current_score:.1f}")
 
     def update_autonomous_behavior(self, time_context: str):
         """
@@ -546,22 +416,18 @@ class NPC:
         else:
             # 일정 확률로 새로운 목표를 생성 (매번 생성하지 않도록)
             if random.random() < 0.1: # 10% 확률
-                print(f"[{self.name}] 새로운 목표를 고민하기 ���작합니다...")
                 self.planner.generate_goal()
 
     def create_symbolic_memory(self):
         """
-        자신의 장기 기억 전체를 바탕으로 상징적인 기억을 생성
+        자신의 기억들을 바탕으로 상징적인 깨달음을 얻음
         """
-        from ..models.llm_helper import query_llm_with_prompt
-
         long_term_memories = self.memory_store.long_term
         if len(long_term_memories) < 10:    # 충분한 기억이 쌓엿을 때만 생성
             return
         
-        print(f"[{self.name}]이(가) 자신의 과거를 깊이 되돌아봅니다...")
-
         # 상징 기억의 주제를 랜덤으로 선택
+        # 수정 필요: 기억에 대한 주제가 랜덤으로 선택되는게 사람 답지 못함
         theme = random.choice([
             "가장 행복했던 순간", "가장 후회되는 일", "나를 가장 화나게 했던 사건",
             "나의 인생에서 가장 중요한 가르침", "최근 나를 가장 성장시킨 경험"
@@ -571,10 +437,10 @@ class NPC:
 
         prompt = f"""
             # 지시사항
-            당신은 '{self.name}'입니다. 다음은 당신의 인생 기억 중 일부입니다.
+            나는 '{self.name}'입니다. 다음은 나의 인생 기억 중 일부입니다.
             이 기억들을 바탕으로, "{theme}"이라는 주제에 대해 당신의 삶을 대표하는 상징적인 의미나 깨달음을 한 문장의 독백으로 생성해주세요.
 
-            # 당신의 기억들
+            # 나의 기억들
             {memory_details}
 
             → "{theme}"에 대한 나의 생각
@@ -590,4 +456,4 @@ class NPC:
                 emotion = "rumination",  # 반추, 성찰과 관련된 감정
                 memory_type="Symbolic",
             )
-            print(f"[{self.name}]의 새로운 깨달음 {symbolic_thought}")
+            print(f"[{self.name}]의 새로운 깨달음: {symbolic_thought}")

npc_social_network/npc/npc_manager.py

@@ -23,17 +23,21 @@ class NPCManager:
         """
         return self.npc_dict.get(name)
     
-    def get_random_npc(self, exclude: ["NPC"]=None) -> Optional["NPC"]:
+    def get_random_npc(self, exclude: Optional['NPC']=None) -> Optional['NPC']:
         """
         특정 NPC를 제외하고 랜덤한 NPC를 선택
-        - 추후 수정 내용: 상대 NPC가 랜덤이 아니라, 상호작용할 만한 근거가 있어야한다.
-        예) 근처에 산다, 특별한 이벤트가 있었다 등 과 같은 이유
+        # 수정 필요: 상대 NPC가 랜덤이 아니라, 상호작용할 만한 근거가 있어야한다.
+        # 예) 근처에 산다, 특별한 이벤트가 있었다 등 과 같은 이유
         """
         possible_targets = [n for n in self.npcs if n != exclude]
         if not possible_targets:
             return None
         return random.choice(possible_targets)
     
+    def all(self) -> List['NPC']:
+        """관리 중인 모든 NPC의 리스트를 반환합니다."""
+        return self.npcs
+    
     def initiate_npc_to_npc_interaction(self, time_context: str):
         """
         NPC 간의 상호작용을 시작시키는 함수
@@ -83,38 +87,3 @@ class NPCManager:
         print(f"[{target.name}]: {response_utterance}")
         print("-------------------------\n")
 
-
-    def move_all(self):
-        for npc in self.npcs:
-            npc.move()
-
-    def draw_all(self, screen, tile_size, image_loader):
-        for npc in self.npcs:
-            npc.draw(screen, tile_size, image_loader)
-
-    def get_npc_at(self, x, y):
-        for npc in self.npcs:
-            nx, ny = npc.get_position()
-            if nx == x and ny == y:
-                return npc
-        return None
-    
-    def all(self):
-        return self.npcs
-    
-    def npc_interactions(self):
-        """
-        모든 NPC가 랜덤으로 다른 NPC 1명에게 상호작용 시도 (임시 함수)
-        """
-        if len(self.npcs) < 2:
-            return # NPC가 2명 이상일 때만 진행
-        
-        #  npc_interactions 진입 확인용
-        print("[NPCManager] npc_interactions() 실행됨.", flush=True)
-        
-        for npc in self.npcs:
-            possible_targets = [n for n in self.npcs if n != npc]
-            target = random.choice(possible_targets)
-            interaction_message = npc.interact_with_npc(target)
-            print(interaction_message)
-

npc_social_network/scenarios/scenario_setup.py

@@ -15,23 +15,23 @@ def setup_initial_scenario(image_loader) -> NPCManager:
     # --- 1. NPC 객체 생성 ---
     # 엘린: 호기심 많고 감정적인 마법사
     personality_elin = {"sensitive": 0.8, "stoic": 0.3, "cognitive_bias": 0.7}
-    elin = NPC("엘린", "마법사", [[2,3], [3,3], [4,3], [5,3], [5,4], [5,5]], ("npc", "default"), personality=personality_elin)
+    elin = NPC("엘린", "마법사", personality=personality_elin)
 
     # 밥: 무뚝뚝하지만 정직한 대장장이
     personality_bob = {"sensitive": 0.2, "stoic": 0.8, "cognitive_bias": 0.4}
-    bob = NPC("밥", "대장장이", [[1,1], [1,2], [2,2], [3,2], [3,1]], ("npc", "default"), personality=personality_bob)
+    bob = NPC("밥", "대장장이", personality=personality_bob)
 
     # 앨리스: 사교적이고 계산적인 상인
     personality_alice = {"sensitive": 0.5, "stoic": 0.5, "cognitive_bias": 0.8}
-    alice = NPC("앨리스", "대장장이", [[8,8], [9,8], [9,9], [8,9]], ("npc", "default"), personality=personality_alice)
+    alice = NPC("앨리스", "대장장이", personality=personality_alice)
 
     # 찰리: 성실하고 평화로운 농부
     personality_charlie = {"sensitive": 0.6, "stoic": 0.6, "cognitive_bias": 0.3}
-    charlie = NPC("찰리", "농부", [[10,3], [11,3], [12,3], [12,4]], ("npc", "default"), personality=personality_charlie)
+    charlie = NPC("찰리", "농부", personality=personality_charlie)
     
     # 다이애나: 조용하고 관찰력 있는 사서
     personality_diana = {"sensitive": 0.7, "stoic": 0.7, "cognitive_bias": 0.9}
-    diana = NPC("다이애나", "사서", [[7,7], [7,8], [8,8]], ("npc", "default"), personality=personality_diana)
+    diana = NPC("다이애나", "사서", personality=personality_diana)
 
     # --- 2. 초기 기억 주입 ---
     elin.remember(content="어젯밤 앨리스와 시장 가격 때문에 크게 다퉜다.", importance=8, emotion="anger")

test.ipynb

@@ -2882,380 +2882,6 @@
     "# GPU 지원 버전으로 다시 설치\n",
     "!pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "8140bcea",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "pygame 2.6.1 (SDL 2.28.4, Python 3.11.11)\n",
-      "Hello from the pygame community. https://www.pygame.org/contribute.html\n",
-      "\n",
-      "👤 Elin (farmer)\n",
-      " - 위치: (5, 4)\n",
-      " - 대화: 오늘은 밭에 나갈 날이군요!\n",
-      " - 기억: []\n",
-      "아침 - Elin이(가) market에 도착했습니다.\n"
-     ]
-    },
-    {
-     "ename": "SystemExit",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "An exception has occurred, use %tb to see the full traceback.\n",
-      "\u001b[31mSystemExit\u001b[39m\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "C:\\Users\\human\\AppData\\Roaming\\Python\\Python311\\site-packages\\IPython\\core\\interactiveshell.py:3675: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
-      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
-     ]
-    }
-   ],
-   "source": [
-    "# pygame simulator 실행기 (임시)\n",
-    "\n",
-    "# 1. 환경 변수 설정 (모듈 인식 위해)\n",
-    "import sys\n",
-    "import os\n",
-    "sys.path.append(os.path.abspath(\".\"))   # 최상위 경로를 sys.path에 추가\n",
-    "\n",
-    "# 2. town_hall 직접 import 후 실행\n",
-    "from npc_social_network.maps.villages import town_hall\n",
-    "\n",
-    "# town_hall.py는 __main__이 아니라 직접 실행되므로"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "ac67ce84",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "초기 감정 상태:\n",
-      "[('fear', 2.2), ('anger', 1.5), ('pride', 1.2)]\n",
-      "감정 평균 강도: 1.63 / 대표 감정: fear(2.2), anger(1.5), pride(1.2)\n",
-      "\n",
-      "[1회 decay 후]\n",
-      "{'core_positive': {'joy': 0.0, 'satisfaction': 0.0, 'gratitude': 0.0, 'calm': 0.0, 'anticipation': 0.0, 'pride': 0.19999999999999996, 'connectedness': 0.0}, 'core_negative': {'sadness': 0.0, 'anger': 1.0, 'anxiety': 0.0, 'disgust': 0.0, 'fear': 1.6, 'regret': 0.0, 'frustration': 0.0}, 'social_emotion': {'jealousy': 0.0, 'shame': 0.0, 'guilt': 0.0, 'compassion': 0.0, 'awe': 0.0, 'empathy': 0.0}, 'cognitive_state': {'confusion': 0.0, 'nervousness': 0.0, 'apathy': 0.0, 'excitement': 0.0, 'immersion': 0.0, 'skepticism': 0.0}}\n",
-      "[('fear', 1.6), ('anger', 1.0), ('pride', 0.2)]\n",
-      "감정 평균 강도: 0.93 / 대표 감정: fear(1.6), anger(1.0), pride(0.2)\n",
-      "\n",
-      "[2회 decay 후]\n",
-      "{'core_positive': {'joy': 0.0, 'satisfaction': 0.0, 'gratitude': 0.0, 'calm': 0.0, 'anticipation': 0.0, 'pride': 0.0, 'connectedness': 0.0}, 'core_negative': {'sadness': 0.0, 'anger': 0.5, 'anxiety': 0.0, 'disgust': 0.0, 'fear': 1.0, 'regret': 0.0, 'frustration': 0.0}, 'social_emotion': {'jealousy': 0.0, 'shame': 0.0, 'guilt': 0.0, 'compassion': 0.0, 'awe': 0.0, 'empathy': 0.0}, 'cognitive_state': {'confusion': 0.0, 'nervousness': 0.0, 'apathy': 0.0, 'excitement': 0.0, 'immersion': 0.0, 'skepticism': 0.0}}\n",
-      "[('fear', 1.0), ('anger', 0.5)]\n",
-      "감정 평균 강도: 0.75 / 대표 감정: fear(1.0), anger(0.5)\n",
-      "\n",
-      "[3회 decay 후]\n",
-      "{'core_positive': {'joy': 0.0, 'satisfaction': 0.0, 'gratitude': 0.0, 'calm': 0.0, 'anticipation': 0.0, 'pride': 0.0, 'connectedness': 0.0}, 'core_negative': {'sadness': 0.0, 'anger': 0.0, 'anxiety': 0.0, 'disgust': 0.0, 'fear': 0.4, 'regret': 0.0, 'frustration': 0.0}, 'social_emotion': {'jealousy': 0.0, 'shame': 0.0, 'guilt': 0.0, 'compassion': 0.0, 'awe': 0.0, 'empathy': 0.0}, 'cognitive_state': {'confusion': 0.0, 'nervousness': 0.0, 'apathy': 0.0, 'excitement': 0.0, 'immersion': 0.0, 'skepticism': 0.0}}\n",
-      "[('fear', 0.4)]\n",
-      "감정 평균 강도: 0.4 / 대표 감정: fear(0.4)\n",
-      "\n",
-      "[4회 decay 후]\n",
-      "{'core_positive': {'joy': 0.0, 'satisfaction': 0.0, 'gratitude': 0.0, 'calm': 0.0, 'anticipation': 0.0, 'pride': 0.0, 'connectedness': 0.0}, 'core_negative': {'sadness': 0.0, 'anger': 0.0, 'anxiety': 0.0, 'disgust': 0.0, 'fear': 0.0, 'regret': 0.0, 'frustration': 0.0}, 'social_emotion': {'jealousy': 0.0, 'shame': 0.0, 'guilt': 0.0, 'compassion': 0.0, 'awe': 0.0, 'empathy': 0.0}, 'cognitive_state': {'confusion': 0.0, 'nervousness': 0.0, 'apathy': 0.0, 'excitement': 0.0, 'immersion': 0.0, 'skepticism': 0.0}}\n",
-      "[]\n",
-      "감정 평균 강도: 0.0 / 대표 감정: 없음\n",
-      "\n",
-      "[5회 decay 후]\n",
-      "{'core_positive': {'joy': 0.0, 'satisfaction': 0.0, 'gratitude': 0.0, 'calm': 0.0, 'anticipation': 0.0, 'pride': 0.0, 'connectedness': 0.0}, 'core_negative': {'sadness': 0.0, 'anger': 0.0, 'anxiety': 0.0, 'disgust': 0.0, 'fear': 0.0, 'regret': 0.0, 'frustration': 0.0}, 'social_emotion': {'jealousy': 0.0, 'shame': 0.0, 'guilt': 0.0, 'compassion': 0.0, 'awe': 0.0, 'empathy': 0.0}, 'cognitive_state': {'confusion': 0.0, 'nervousness': 0.0, 'apathy': 0.0, 'excitement': 0.0, 'immersion': 0.0, 'skepticism': 0.0}}\n",
-      "[]\n",
-      "감정 평균 강도: 0.0 / 대표 감정: 없음\n"
-     ]
-    }
-   ],
-   "source": [
-    "# 1. 경로 추가\n",
-    "import sys, os\n",
-    "sys.path.append(os.path.abspath(\".\"))  # 프로젝트 루트 경로\n",
-    "\n",
-    "# 2. 클래스 import\n",
-    "from npc_social_network.npc.npc_base import NPC\n",
-    "\n",
-    "# 3. NPC 생성 및 감정 입력\n",
-    "npc = NPC(name=\"아린\", job=\"farmer\", path=[(0,0)], image=None)\n",
-    "npc.remember(\"플레이어가 모욕함\", importance=6, emotion=\"anger\", strength=1.5)\n",
-    "npc.remember(\"무서운 소리를 들음\", importance=5, emotion=\"fear\", strength=2.2)\n",
-    "npc.remember(\"친구가 칭찬함\", importance=5, emotion=\"pride\", strength=1.2)\n",
-    "\n",
-    "print(\"초기 감정 상태:\")\n",
-    "print(npc.get_composite_emotion_state())         # [('fear', 2.0), ('anger', 1.5), ('pride', 1.2)]\n",
-    "print(npc.summarize_emotional_state())           # 감정 평균 강도: 1.57 / 대표 감정: fear(2.0), anger(1.5), pride(1.2)\n",
-    "\n",
-    "# 4. decay 반복 적용\n",
-    "for step in range(1, 6):\n",
-    "    npc.decay_emotion()\n",
-    "    print(f\"\\n[{step}회 decay 후]\")\n",
-    "    print(npc.get_current_emotion_state())\n",
-    "    print(npc.get_composite_emotion_state())\n",
-    "    print(npc.summarize_emotional_state())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "cc6f2948",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "감정 평균 강도: 0.96 / 대표 감정: fear(0.96)\n"
-     ]
-    }
-   ],
-   "source": [
-    "from npc_social_network.npc.npc_base import NPC\n",
-    "\n",
-    "# 민감하고 부정에 취약한 캐릭터\n",
-    "custom_personality = {\n",
-    "    \"sensitive\": 1.0,\n",
-    "    \"negative_bias\": 1.5,\n",
-    "    \"stoic\": 0.1\n",
-    "}\n",
-    "\n",
-    "npc = NPC(\"아린\", \"farmer\", [(0, 0)], None, personality=custom_personality)\n",
-    "npc.remember(\"무서운 소리를 들음\", emotion=\"fear\", importance=5)\n",
-    "npc.decay_emotion()\n",
-    "print(npc.summarize_emotional_state())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "9638a156",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "로다와의 관계 점수: 7.0\n",
-      "로다와의 관계 설명: 호감 있음\n"
-     ]
-    }
-   ],
-   "source": [
-    "# 7단계 NPC 관계 시스템 테스트\n",
-    "from npc_social_network.npc.npc_base import NPC\n",
-    "\n",
-    "npc1 = NPC(name=\"아린\", job=\"farmer\", path=[(0,0)], image=None)\n",
-    "npc2 = NPC(name=\"로다\", job=\"blacksmith\", path=[(0,1)], image=None)\n",
-    "\n",
-    "npc1.interact_with(\"로다\", emotion=\"joy\", positive=True)\n",
-    "npc1.interact_with(\"로다\", emotion=\"anger\", positive=True)\n",
-    "\n",
-    "print(\"로다와의 관계 점수:\", npc1.relationships.get_relationship(\"로다\"))\n",
-    "print(\"로다와의 관계 설명:\", npc1.get_relationship_description(\"로다\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "53c994dd",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "로다와의 관계 점수: 9.5\n",
-      "로다와의 관계 설명: 호감 있음\n"
-     ]
-    }
-   ],
-   "source": [
-    "# 8단계 관계 + 감정 + 기억 연동\n",
-    "from npc_social_network.npc.npc_base import NPC\n",
-    "\n",
-    "npc1 = NPC(name=\"아린\", job=\"farmer\", path=[(0,0)], image=None)\n",
-    "\n",
-    "# 중요 기억 등록\n",
-    "npc1.remember(\"로다와 좋은 시간을 보냄\", importance=8, emotion=\"joy\")\n",
-    "npc1.remember(\"로다에게 도움을 받음\", importance=9, emotion=\"gratitude\")\n",
-    "npc1.remember(\"로다에게 실망함\", importance=7, emotion=\"anger\")\n",
-    "\n",
-    "# 현재 감정 입력\n",
-    "npc1.remember(\"최근 로다와 유대감 형성\", importance=6, emotion=\"connectedness\")\n",
-    "\n",
-    "# 관계 반영\n",
-    "npc1.reflect_memory_on_relationship(\"로다\")\n",
-    "\n",
-    "# 결과 출력\n",
-    "print(\"로다와의 관계 점수:\", npc1.relationships.get_relationship(\"로다\"))\n",
-    "print(\"로다와의 관계 설명:\", npc1.get_relationship_description(\"로다\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "69387020",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[('sadness', 1.44), ('joy', 0.96), ('gratitude', 0.72)]\n",
-      "아린 행동 시퀀스: \n",
-      "(1.4) 슬퍼서 주저앉습니다....\n",
-      "(1.0) 기뻐서 깡충 뜁니다.\n",
-      "(0.7) 감사한 마음을 표현합니다.\n",
-      "밭일도 해야 하겠군요.\n"
-     ]
-    }
-   ],
-   "source": [
-    "# 9단계 복합 감정 - 행동 시퀀스 구성\n",
-    "from npc_social_network.npc.npc_base import NPC\n",
-    "\n",
-    "npc = NPC(name=\"아린\", job=\"farmer\", path=[(0,0)], image=None)\n",
-    "\n",
-    "# 여러 감정 기억 등록\n",
-    "npc.remember(\"칭찬받아 기쁨\", importance=7, emotion=\"joy\", strength=2.0)\n",
-    "npc.remember(\"동료가 위로함\", importance=8, emotion=\"gratitude\", strength=1.5)\n",
-    "npc.remember(\"실망스러운 일 겪음\", importance=8, emotion=\"sadness\", strength=1.8)\n",
-    "print(npc.get_composite_emotion_state())\n",
-    "\n",
-    "# 복합 감정 기반 행동 시퀀스 출력\n",
-    "print(npc.generate_dialogue())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "246a140b",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "[플레이어 입력] 오늘 하루는 최악이었어. 왜 다들 날 무시하는 거지?\n",
-      "[요약 실패] LLM 호출 중 에러가 발생하여 요약 기억을 저장하지 않습니다. 에러: [LLM Error] 500 An internal error has occurred. Please retry or report in https://developers.generativeai.google/guide/troubleshooting\n",
-      "[Personality Update] 엘라 → sensitive: 1.00, stoic: 0.00, cognitive_bias: 1.00\n",
-      "[NPC 응답] ...어... 그랬어? 하루가 최악이었다니... 정말 힘들었겠구나.\n",
-      "\n",
-      "(잠깐 침묵하며 네 얼굴을 가만히 바라봐.)\n",
-      "\n",
-      "무시당하는 기분이라는 게... 얼마나 사람을 서글프게 만드는지, 나도... 조금은 알 것 같아. 마음이 많이 아팠겠네.\n",
-      "\n",
-      "무슨 일이 있었던 거야? 괜찮다면... 나에게 이야기해 줄 수 있을까? 네 이야기를 들으면... 조금이라도 마음이 편해질지도 모르잖아.\n",
-      "\n",
-      "[플레이어 입력] 고마워. 나 도와줘서 정말 감사했어.\n",
-      "[요약 기억 저장됨] 이 사람은 과거에 무시당하는 느낌을 경험했던 것으로 보이며, 최근에는 찰리와 농사를 짓고 밥에게 선물을 받는 등 사람들과 교류하며 다양한 경험을 했고 특히 어제 앨리스와 심하게 다투기도 했습니다.\n",
-      "[Personality Update] 엘라 → sensitive: 1.00, stoic: 0.00, cognitive_bias: 1.00\n",
-      "[NPC 응답] \"...아, 고마워. (조금 생각하는 듯) 음... 아니야. 나야말로... 음, 그냥 도울 수 있어서 좋았어. 플레이어 네가 그렇게 고마워해주니... 나도 기쁘네. (아주 살짝 미소) 별거 아니었는데, 그렇게 말해주니 참... 좋네.\"\n",
-      "\n",
-      "[플레이어 입력] 그때 화낸 건 미안해. 내 잘못이었어.\n",
-      "[요약 기억 저장됨] 제시된 정보를 종합해 보면, 이 사람은 최근 찰리와 함께 농사를 짓거나 밥에게 검을 선물받는 등 다양한 사람들과 교류하며 여러 경험을 했습니다. 특히 어제는 앨리스와 심하게 다투기도 했습니다.\n",
-      "[Personality Update] 엘라 → sensitive: 1.00, stoic: 0.00, cognitive_bias: 1.00\n",
-      "[NPC 응답] 아, 아니에요. 괜찮아요.\n",
-      "\n",
-      "그렇게 말해주니 오히려 마음이 좀 편해지네요. 저도 그때 조금... 신경 쓰였거든요.\n",
-      "\n",
-      "그래도 이렇게 먼저 말해줘서 고마워요. 이제 정말 괜찮아요.\n",
-      "\n",
-      "[플레이어 입력] 내가 선물한 책 어땠어?\n",
-      "[요약 기억 저장됨] 이 사람은 최근 찰리와 함께 농사를 짓고 밥에게 선물을 받는 등 다양한 사람들과 교류했으며, 어제는 앨리스와 심하게 다투는 큰 갈등을 겪었습니다.\n",
-      "[Personality Update] 엘라 → sensitive: 1.00, stoic: 0.00, cognitive_bias: 1.00\n",
-      "[NPC 응답] 아, 그 책! 정말... 정말 좋았어! 네가 나에게 딱 맞는 책을 선물해줬구나 싶어서 읽는 내내 기뻤어.\n",
-      "\n",
-      "특히 거기에 담긴 마법 이론에 대한 새로운 접근 방식이... 내 생각을 정말 많이 자극했어. 평소에 내가 고민하던 부분에 대한 실마리를 찾은 것 같기도 하고 말이야.\n",
-      "\n",
-      "네 덕분에 정말 즐거운 시간을 보낼 수 있었어. 고마워! 요즘 이것저것 신경 쓸 일이 좀 있었는데, 책 읽는 동안은 다 잊고 몰입할 수 있었어. 네 덕분이야.\n",
-      "\n",
-      "혹시 너도 그 책 읽어봤어? 어떤 부분이 가장 흥미로웠는지 궁금하네.\n",
-      "\n",
-      "[플레이어 ��력] 우리 예전에 함께 일했던 거 기억나?\n",
-      "[요약 실패] LLM 호출 중 에러가 발생하여 요약 기억을 저장하지 않습니다. 에러: [LLM Error] 500 An internal error has occurred. Please retry or report in https://developers.generativeai.google/guide/troubleshooting\n",
-      "[Personality Update] 엘라 → sensitive: 1.00, stoic: 0.00, cognitive_bias: 1.00\n",
-      "[NPC 응답] 우리 예전에 함께 일했던 거? 어머, 당연히 기억하지! 😊\n",
-      "\n",
-      "그때 생각하면... 왠지 모르게 기분이 좋아져. 함께 했던 시간들은... 나에게는 좋은 기억으로 남아있거든. 왜 갑자기 그 생각이 났어?\n",
-      " - 기억 '[입력] '고마워. 나 도와줘서 정말...' (감정: joy, 중요도: 7) -> 관계에 1.4만큼의 강도로 영향을 줍니다.\n",
-      "[관계 업데이트 완료] 플레이어와의 최종 관계 점수: 12.1\n",
-      "\n",
-      "🧠 현재 감정 상태 요약:\n",
-      "감정 평균 강도: joy / 대표 감정: [('joy', 3.0), ('interest', 3.0), ('relief', 3.0)]\n",
-      "\n",
-      "📚 최근 기억:\n",
-      "- [입력] '우리 예전에 함께 일했던 거 기억나?' → [응답] '우리 예전에 함께 일했던 거? 어머, 당연히 기억하지! 😊\n",
-      "\n",
-      "그때 생각하면... 왠지 모르게 기분이 좋아져. 함께 했던 시간들은... 나에게는 좋은 기억으로 남아있거든. 왜 갑자기 그 생각이 났어?' (nostalgia)\n",
-      "- [입력] '내가 선물한 책 어땠어?' → [응답] '아, 그 책! 정말... 정말 좋았어! 네가 나에게 딱 맞는 책을 선물해줬구나 싶어서 읽는 내내 기뻤어.\n",
-      "\n",
-      "특히 거기에 담긴 마법 이론에 대한 새로운 접근 방식이... 내 생각을 정말 많이 자극했어. 평소에 내가 고민하던 부분에 대한 실마리를 찾은 것 같기도 하고 말이야.\n",
-      "\n",
-      "네 덕분에 정말 즐거운 시간을 보낼 수 있었어. 고마워! 요즘 이것저것 신경 쓸 일이 좀 있었는데, 책 읽는 동안은 다 잊고 몰입할 수 있었어. 네 덕분이야.\n",
-      "\n",
-      "혹시 너도 그 책 읽어봤어? 어떤 부분이 가장 흥미로웠는지 궁금하네.' (gratitude)\n",
-      "- 이 사람은 최근 찰리와 함께 농사를 짓고 밥에게 선물을 받는 등 다양한 사람들과 교류했으며, 어제는 앨리스와 심하게 다투는 큰 갈등을 겪었습니다. (joy)\n",
-      "- [입력] '그때 화낸 건 미안해. 내 잘못이었어.' → [응답] '아, 아니에요. 괜찮아요.\n",
-      "\n",
-      "그렇게 말해주니 오히려 마음이 좀 편해지네요. 저도 그때 조금... 신경 쓰였거든요.\n",
-      "\n",
-      "그래도 이렇게 먼저 말해줘서 고마워요. 이제 정말 괜찮아요.' (relief)\n",
-      "- 제시된 정보를 종합해 보면, 이 사람은 최근 찰리와 함께 농사를 짓거나 밥에게 검을 선물받는 등 다양한 사람들과 교류하며 여러 경험을 했습니다. 특히 어제는 앨리스와 심하게 다투기도 했습니다. (joy)\n",
-      "\n",
-      "🔗 플레이어와의 관계:\n",
-      "호감 있음\n"
-     ]
-    }
-   ],
-   "source": [
-    "# portfolio/test.ipynb\n",
-    "\n",
-    "import time\n",
-    "from npc_social_network.routes.npc_route import npc_manager\n",
-    "\n",
-    "def run_npc_test_scenario(npc_name=\"엘라\"):\n",
-    "    npc = npc_manager.get_npc_by_name(npc_name)\n",
-    "\n",
-    "    test_inputs = [\n",
-    "        \"오늘 하루는 최악이었어. 왜 다들 날 무시하는 거지?\",\n",
-    "        \"고마워. 나 도와줘서 정말 감사했어.\",\n",
-    "        \"그때 화낸 건 미안해. 내 잘못이었어.\",\n",
-    "        \"내가 선물한 책 어땠어?\",\n",
-    "        \"우리 예전에 함께 일했던 거 기억나?\",\n",
-    "    ]\n",
-    "\n",
-    "    for input_text in test_inputs:\n",
-    "        print(f\"\\n[플레이어 입력] {input_text}\")\n",
-    "        response = npc.generate_dialogue(input_text)\n",
-    "        print(f\"[NPC 응답] {response}\")\n",
-    "\n",
-    "    # 기억 기반 관계 반영까지 테스트\n",
-    "    npc.reflect_memory_emotions_on_relationship(\"플레이어\")\n",
-    "\n",
-    "    # 상태 요약 출력\n",
-    "    print(\"\\n🧠 현재 감정 상태 요약:\")\n",
-    "    print(npc.summarize_emotional_state())\n",
-    "\n",
-    "    print(\"\\n📚 최근 기억:\")\n",
-    "    for m in npc.memory_store.get_recent_memories(limit=5):\n",
-    "        print(f\"- {m.content} ({m.emotion})\")\n",
-    "\n",
-    "    print(\"\\n🔗 플레이어와의 관계:\")\n",
-    "    print(npc.get_relationship_description(\"플레이어\"))\n",
-    "\n",
-    "\n",
-    "run_npc_test_scenario()"
-   ]
   }
  ],
  "metadata": {