flask를 통해 백엔드 구축

app.py

@@ -1,12 +1,11 @@
 # portfolio/app.py
 from flask import Flask, render_template, url_for, redirect
 from npc_social_network.routes.npc_route import npc_bp
+from npc_social_network import simulation_core
 # from stock.routes.stock_route import stock_bp
 import os
 import subprocess
 
-# 시뮬레이션 프로세스를 관리할 전역 변수
-simulation_process = None
 
 def create_app():
     app = Flask(__name__) # static/template 경로를 기본값
@@ -15,29 +14,20 @@ def create_app():
     app.register_blueprint(npc_bp)
     # app.register_blueprint(stock_bp)
 
+    # 포트폴리오의 메인 랜딩 페이지
     @app.route("/")
     def index():
         return render_template("main.html")
     
-    @app.route("/run_npc_simulation")
-    def run_npc_simulation():
-        global simulation_process
-        # 이미 실행 중인 프로세스가 있다면 종료
-        if simulation_process and simulation_process.poll() is None:
-            simulation_process.terminate()
-            simulation_process.wait()
-
-        # 파이썬 가상환경의 실행 파일 경로를 명시적으로 지정할 수 있음
-        python_exec = "python" 
-        # 비동기로 Pygame 시뮬레이션 실행
-        subprocess.Popen([python_exec, "-m", "npc_social_network.maps.villages.town_hall"]) # 비동기로 실행 (창 띄움)
-
-        # 실행 후 사용자 안내 페이지 표시
-        return redirect(url_for('npc_social.home'))
-    
     return app
 
 if __name__ == '__main__':
+    # 1. flask 앱 실행
     app = create_app()
-    print("[MAIN] Starting Flask app only (Background NPC interactions handled by separate runner).", flush=True)
-    app.run(debug=True, use_reloader=False)
+    # 2. NPC 시뮬레이션 초기화 및 백그라운드 스레드 시작
+    simulation_core.initialize_simulation()
+    
+    # 3. Flask 웹 서버 실행
+    # use_reloader=False는 디버그 모드에서 앱이 두 번 실행되는 것을 방지하여,
+    # 시뮬레이션 스레드가 두 번 시작되지 않도록 합니다.
+    app.run(debug=True, use_reloader=False, port=5000)

npc_social_network/npc/npc_base.py

@@ -231,11 +231,11 @@ class NPC:
         self.emotion.update_emotion(emotion, strength)
         self._emotion_buffer = self.emotion.get_buffer()
 
-    def decay_emotion(self):
+    def decay_emotions(self):
         """
         시간이 지남에 따라 모든 감정이 서서히 감소
         """
-        self.emotion.decay_emotion()
+        self.emotion.decay_emotions()
         self._emotion_buffer = self.emotion.get_buffer()
 
     def recall_all_memories(self) -> List[str]:
@@ -334,7 +334,7 @@ class NPC:
         print(f"[Personality Update] {self.name} → sensitive: {self.personality['sensitive']:.3f}, "
               f"stoic: {self.personality['stoic']:.3f}, cognitive_bias: {self.personality['cognitive_bias']:.3f}", flush=True)
 
-    def decay_memory(self):
+    def decay_memories(self):
         """
         시간이 지남에 따라 기억 importance 감소
         - MemoryStore의 decay_memories에 self(NPC 객체)를 전달
@@ -388,7 +388,7 @@ class NPC:
         summary = summarize_memories(memories)
         if "[LLM Error]" in summary: return
         self.remember(
-            Memory(content=f"[요약된 기억] summary",
+            Memory(content=f"[요약된 기억] {summary}",
                    importance=9,
                    emotion=self.emotion.get_dominant_emotion(),
                    memory_type="Summary")

npc_social_network/routes/npc_route.py

@@ -1,11 +1,9 @@
 # portfolio/npc_social_network/routes/npc_route.py
-from flask import Blueprint, render_template, request, jsonify
-from npc_social_network.models.gemini_setup import load_gemini
+from flask import Blueprint, render_template, request, jsonify, url_for
+from .. import simulation_core
 from npc_social_network.maps.manager.simulation_manager import load_simulation, save_simulation
 from ..npc.npc_manager import NPCManager
-from npc_social_network.npc.npc_memory_embedder import embed_npc_memories, search_similar_memories
-import threading
-import time
+
 
 npc_bp = Blueprint(
     "npc_social",
@@ -14,58 +12,99 @@ npc_bp = Blueprint(
     template_folder="../templates",
     static_folder="../static")
 
-# LLM Model
-llm_model = load_gemini()
+# --------------------------------------------------
+# API 엔드포인트 정의
+# --------------------------------------------------
+@npc_bp.route("/")
+def dashboard():
+    """월드 관찰자 대시보드 페이지를 렌더링합니다."""
+    return render_template("dashboard.html")
 
-def get_npc_manager() -> NPCManager:
-    """
-    저장된 시뮬레이션 상태 파일을 불러와 NPC 매니저를 가져옵니다.
-    웹은 이 함수를 통해서만 NPC 데이터에 접근합니다.
-    """
-    npc_manager = load_simulation()
-    if npc_manager is None:
-        # 만약 저장 파일이 없다면, 웹 UI가 비어있지 않도록 임시 매니저를 생성.
-        npc_manager = NPCManager()
-    return npc_manager
+@npc_bp.route("api/world_state", method=['GET'])
+def get_world_state():
+    """프론트엔드에 전달할 월드 전체 데이터를 JSON으로 반환합니다."""
+    if not simulation_core.npc_manager:
+        return jsonify({"error":"Simulation not started"}), 500
+    
+    nodes = []
+    for npc in simulation_core.npc_manager.all():
+        nodes.append({
+            "id": npc.name,
+            "label": npc.name,
+            "shape": "image",
+            "image": url_for('npc_social.static', filename=f'image/npc/npc{npc.name.lower()}.png'),
+            "job": npc.job,
+            "age": npc.age
+        })
 
-# --------------------
-# 라우트 정의
-# --------------------
+    edges = []
+    drawn_relations = set()
+    for npc in simulation_core.npc_manager.all():
+        for target_name, profile in npc.relationships.relationships.items():
+            relation_pair = tuple(sorted(npc.name, target_name))
+            if relation_pair in drawn_relations: continue
 
-@npc_bp.route("/", methods=['GET'])
-def home():
-    # 웹 페이지가 처음 로드될 때, 저장된 NPC 목록을 전달
-    npc_manager = get_npc_manager()
-    npc_names = list(npc_manager.npc_dict.keys())
-    # chat.html에 시뮬레이션 실행 상태와 NPC 목록을 전달
-    return render_template("chat.html", npc_names=npc_names or ["(시뮬레이션 미실행)"])
+            color = {"best friend": "#0400FF", "friend": "#00FF00", "acquaintance": "#68D4FF",
+                    "nuisance": "#FCF814", "rival": "#FF9E0D", "enemy": "#FF0000",
+                    "stranger":"#5E5C5C" }.get(profile.type, "gray")
+            
+            edges.append({
+                "from": npc.name,
+                "to": target_name,
+                "label": f"{profile.type} ({profile.score: .1f})",
+                "color": color,
+                "width": 2
+            })
+            drawn_relations.add(relation_pair)
 
-# 채팅 처리 API
-@npc_bp.route("/chat", methods=['POST'])
-def chat():
-    """웹 채팅 상호작용 후, 변경된 상태 파일에 저장"""
-    npc_manager = get_npc_manager()
-    if not npc_manager.all():
-         return jsonify({"error": "시뮬레이션이 실행되지 않았습니다. 먼저 시뮬레이션을 시작해주세요."}), 400
-    
-    user_input = request.json.get("message")
-    npc_name = request.json.get("npc")
-    npc = npc_manager.get_npc_by_name(npc_name)
-    
-    if npc is None:
-        return jsonify({"error": "NPC를 찾을 수 없습니다."}), 404
+    return jsonify({
+        "nodes": nodes,
+        "edges": edges,
+        "log": simulation_core.event_log,
+        "paused": simulation_core.simulation_paused
+    })
 
-    # generate_dialogue가 time_context를 요구하므로 임시 값을 전달
-    # generate_dialogue를 통해 응답 생성 및 내부 상태 업데이트
-    npc_reply = npc.generate_dialogue(user_input, time_context="Web Interaction")
+@npc_bp.route("/api/npc_details/<npc_name>", methods=['GET'])
+def get_npc_details(npc_name):
+    npc = simulation_core.npc_manager.get_npc_by_name(npc_name)
+    if not npc:
+        return jsonify({"error": "NPC not found"}), 404
 
-    # 상호작용 후 변경된 상태를 저장
-    save_simulation(npc_manager)
+    details = {
+        "name": npc.name, "age": npc.age, "job": npc.job,
+        "personality_summary": npc.personality.get_personality_summary(),
+        "emotions": npc.get_composite_emotion_state(top_n=5),
+        "goals": npc.planner.current_goal.description if npc.planner.has_active_plan() else "���별한 목표 없음",
+        "memories": [mem.content for mem in npc.memory_store.get_recent_memories(limit=10)]
+    }
+    return jsonify(details)
 
-    return jsonify({
-        "npc_reply": npc_reply,
-        "dominant_emotion": npc.emotion.get_dominant_emotion(),
-        "memory_summary": npc.summarize_emotional_state(),
-        "emotion_state": npc.get_composite_emotion_state(),
-        "relationship_with_player": npc.get_relationship_description("플레이어")
-    })
+@npc_bp.route("/api/toggle_simulation", methods=['POST'])
+def toggle_simulation():
+    simulation_core.simulation_paused = not simulation_core.simulation_paused
+    status = "정지됨" if simulation_core.simulation_paused else "실행 중"
+    simulation_core.add_log(f"시뮬레이션이 {status} 상태로 변경되었습니다.")
+    return jsonify({"paused": simulation_core.simulation_paused})
+
+@npc_bp.route("/api/manual_tick", methods=['POST'])
+def manual_tick():
+    # 수동 틱은 시뮬레이션이 멈춰있을 때만 작동하도록 함
+    if simulation_core.simulation_paused:
+        simulation_core.tick_simulation()
+    else:
+        simulation_core.add_log("경고: 시뮬레이션이 실행 중일 때는 수동 틱을 할 수 없습니다.")
+    return get_world_state()
+
+
+@npc_bp.route("/api/inject_event", methods=['POST'])
+def inject_event():
+    """플레이어가 NPC에게 이벤트를 직접 주입하는 함수"""
+    data = request.json
+    npc_name, event_text = data.get("npc_name"), data.get("event_text")
+    npc = simulation_core.npc_manager.get_npc_by_name(npc_name)
+    
+    if npc and event_text:
+        npc.remember(content=f"[요약된 기억] {event_text}", importance=10, emotion="surprise", memory_type="Summary")      # 수정 필요: importance, emotion 값을 요약된 기억에 맞게 넣어줄 함수
+        simulation_core.add_log(f"{npc_name}: '{event_text}'")
+        return jsonify({"success": True})
+    return jsonify({"success": False, "error": "Invalid data"}), 400

npc_social_network/simulation_core.py

@@ -0,0 +1,68 @@
+# npc_social_network/simulation_core.py
+# 시뮬레이션의 '상태 저장소' & '엔진'
+
+import threading
+import time
+from .npc.npc_manager import NPCManager
+from .scenarios.scenario_setup import setup_initial_scenario
+from .manager.simulation_manager import save_simulation, load_simulation
+
+#------------------------------------------
+# 1. 시뮬레이션 상태 (전역 변수)
+# - 이 변수들이 시뮬레이션 세계의 모든 정보를 담습니다.
+#------------------------------------------
+npc_manager: NPCManager = None
+simulation_paused = True
+event_log = []
+
+#------------------------------------------
+# 2. 시뮬레이션 로진 함수
+#------------------------------------------
+def add_log(message):
+    """이벤트 로그에 메시지를 추가합니다."""
+    timestamp = time.strftime("%H:%M:%S")
+    print(f"[{timestamp}] {message}")
+    event_log.insert(0, f"[{timestamp}] {message}")
+    if len(event_log) > 100:
+        event_log.pop()
+
+def tick_simulation():
+    """시뮬레이션의 시간을 한 단계 진행"""
+    if not npc_manager or simulation_paused:
+        return
+    
+    add_log("시뮬레이션 틱 시작")
+
+    for npc in npc_manager.all():
+        npc.decay_emotions()
+        npc.decay_memories()
+        npc.update_autonomous_behavior("자율 행동 시간")
+
+    if len(npc_manager.all()) >= 2:
+        try:
+            add_log("NPC 간 자율 상호작용을 시도합니다.")
+            npc_manager.initiate_npc_to_npc_interaction("자율 행동 시간")
+        except Exception as e:
+            add_log(f"상호작용 중 오류 발생: {e}")
+
+def simulation_loop():
+    """백그라운드에서 주기적으로 시뮬레이션을 실행하는 루프"""
+    add_log("백그라운드 시뮬레이션 루프 시작됨.")
+    while True:
+        if not simulation_paused:
+            tick_simulation()
+        time.sleep(5)   # 5초에 한 번씩 틱 발생
+
+def initialize_simulation():
+    """서버 시작 시 시뮬레이션을 초기화합니다."""
+    global npc_manager
+    npc_manager = load_simulation()
+    if npc_manager is None:
+        npc_manager = setup_initial_scenario()
+        save_simulation(npc_manager)
+
+    add_log("시뮬레이션이 성공적으로 초기화되었습니다.")
+
+    # 백그라운드 스레드에서 시뮬레이션 루프 시작
+    simulation_thread = threading.Thread(target=simulation_loop, daemon=True)
+    simulation_thread.start()