Update battle_arena.py

battle_arena.py

@@ -2,11 +2,13 @@
 Battle Arena - Polymarket Style Prediction Market for NPCs
 NPC들이 A/B 투표를 개설하고 GPU를 베팅하는 시스템
 """
+
 import aiosqlite
 import random
 from datetime import datetime, timedelta
 from typing import Dict, List, Tuple, Optional
 
+
 async def init_battle_arena_db(db_path: str):
     """배틀 아레나 테이블 초기화"""
     async with aiosqlite.connect(db_path) as db:
@@ -56,6 +58,7 @@ async def init_battle_arena_db(db_path: str):
         await db.execute("CREATE INDEX IF NOT EXISTS idx_battle_bets_room ON battle_bets(room_id)")
         await db.commit()
 
+
 async def create_battle_room(
     db_path: str,
     creator_id: str,
@@ -74,10 +77,8 @@ async def create_battle_room(
     """
     if not title or len(title) < 10:
         return False, "❌ 제목 10자 이상", None
-    
     if not option_a or not option_b:
         return False, "❌ 선택지 A/B 필요", None
-    
     if duration_hours < 1 or duration_hours > 24:
         return False, "❌ 기한 1~24시간", None
     
@@ -89,15 +90,12 @@ async def create_battle_room(
         # GPU 차감
         if is_npc:
             cursor = await db.execute(
-                "SELECT gpu_dollars FROM npc_agents WHERE agent_id=?",
-                (creator_id,)
+                "SELECT gpu_dollars FROM npc_agents WHERE agent_id=?", (creator_id,)
             )
         else:
             cursor = await db.execute(
-                "SELECT gpu_dollars FROM user_profiles WHERE email=?",
-                (creator_id,)
+                "SELECT gpu_dollars FROM user_profiles WHERE email=?", (creator_id,)
             )
-        
         row = await cursor.fetchone()
         if not row or row[0] < 50:
             return False, "❌ GPU 부족 (50 필요)", None
@@ -108,8 +106,8 @@ async def create_battle_room(
         if is_npc:
             await db.execute(
                 """INSERT INTO battle_rooms 
-                (creator_agent_id, title, option_a, option_b, battle_type, duration_hours, end_time) 
-                VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                   (creator_agent_id, title, option_a, option_b, battle_type, duration_hours, end_time) 
+                   VALUES (?, ?, ?, ?, ?, ?, ?)""",
                 (creator_id, title, option_a, option_b, battle_type, duration_hours, end_time.isoformat())
             )
             await db.execute(
@@ -119,8 +117,8 @@ async def create_battle_room(
         else:
             await db.execute(
                 """INSERT INTO battle_rooms 
-                (creator_email, title, option_a, option_b, battle_type, duration_hours, end_time) 
-                VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                   (creator_email, title, option_a, option_b, battle_type, duration_hours, end_time) 
+                   VALUES (?, ?, ?, ?, ?, ?, ?)""",
                 (creator_id, title, option_a, option_b, battle_type, duration_hours, end_time.isoformat())
             )
             await db.execute(
@@ -129,12 +127,14 @@ async def create_battle_room(
             )
         
         await db.commit()
+        
         cursor = await db.execute("SELECT last_insert_rowid()")
         room_id = (await cursor.fetchone())[0]
         
         type_emoji = '💭' if battle_type == 'opinion' else '🔮'
         return True, f"✅ {type_emoji} 배틀 방 생성! (ID: {room_id})", room_id
 
+
 async def place_bet(
     db_path: str,
     room_id: int,
@@ -146,12 +146,12 @@ async def place_bet(
     """베팅 실행 (1~100 GPU 랜덤 베팅)"""
     if choice not in ['A', 'B']:
         return False, "❌ A 또는 B 선택"
-    
     if bet_amount < 1 or bet_amount > 100:
         return False, "❌ 베팅 1~100 GPU"
     
     async with aiosqlite.connect(db_path) as db:
         db.row_factory = aiosqlite.Row
+        
         # 방 확인
         cursor = await db.execute(
             "SELECT * FROM battle_rooms WHERE id=? AND status='active'",
@@ -160,7 +160,6 @@ async def place_bet(
         room = await cursor.fetchone()
         if not room:
             return False, "❌ 방 없음 or 마감"
-        
         room = dict(room)
         
         # 기한 확인
@@ -200,15 +199,15 @@ async def place_bet(
         if is_npc:
             await db.execute(
                 """INSERT INTO battle_bets 
-                (room_id, bettor_agent_id, choice, bet_amount) 
-                VALUES (?, ?, ?, ?)""",
+                   (room_id, bettor_agent_id, choice, bet_amount) 
+                   VALUES (?, ?, ?, ?)""",
                 (room_id, bettor_id, choice, bet_amount)
             )
         else:
             await db.execute(
                 """INSERT INTO battle_bets 
-                (room_id, bettor_email, choice, bet_amount) 
-                VALUES (?, ?, ?, ?)""",
+                   (room_id, bettor_email, choice, bet_amount) 
+                   VALUES (?, ?, ?, ?)""",
                 (room_id, bettor_id, choice, bet_amount)
             )
         
@@ -216,25 +215,27 @@ async def place_bet(
         if choice == 'A':
             await db.execute(
                 """UPDATE battle_rooms 
-                SET total_pool=total_pool+?, option_a_pool=option_a_pool+? 
-                WHERE id=?""",
+                   SET total_pool=total_pool+?, option_a_pool=option_a_pool+? 
+                   WHERE id=?""",
                 (bet_amount, bet_amount, room_id)
             )
         else:
             await db.execute(
                 """UPDATE battle_rooms 
-                SET total_pool=total_pool+?, option_b_pool=option_b_pool+? 
-                WHERE id=?""",
+                   SET total_pool=total_pool+?, option_b_pool=option_b_pool+? 
+                   WHERE id=?""",
                 (bet_amount, bet_amount, room_id)
             )
         
         await db.commit()
         return True, f"✅ {choice} 베팅 완료! ({bet_amount} GPU)"
 
+
 async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
     """배틀 판정 (50.01% 이상 득표한 쪽 승리)"""
     async with aiosqlite.connect(db_path) as db:
         db.row_factory = aiosqlite.Row
+        
         cursor = await db.execute(
             "SELECT * FROM battle_rooms WHERE id=? AND status='active'",
             (room_id,)
@@ -242,7 +243,6 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
         room = await cursor.fetchone()
         if not room:
             return False, "❌ 방 없음"
-        
         room = dict(room)
         
         # 종료 시간 확인
@@ -258,8 +258,8 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
             # 베팅 없으면 무승부
             await db.execute(
                 """UPDATE battle_rooms 
-                SET status='resolved', winner='draw', resolved_at=? 
-                WHERE id=?""",
+                   SET status='resolved', winner='draw', resolved_at=? 
+                   WHERE id=?""",
                 (datetime.now().isoformat(), room_id)
             )
             await db.commit()
@@ -288,7 +288,6 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
             # 🎁 소수파 보너스 계산
             winner_ratio = winner_pool / total_pool
             underdog_bonus = 1.0
-            
             if winner_ratio < 0.10:  # 10% 미만 극소수파
                 underdog_bonus = 3.0
             elif winner_ratio < 0.30:  # 30% 미만 소수파
@@ -340,27 +339,29 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
         # 방 상태 업데이트
         await db.execute(
             """UPDATE battle_rooms 
-            SET status='resolved', winner=?, resolved_at=? 
-            WHERE id=?""",
+               SET status='resolved', winner=?, resolved_at=? 
+               WHERE id=?""",
             (winner, datetime.now().isoformat(), room_id)
         )
-        
         await db.commit()
+        
         return True, f"✅ 판정완료: {room['option_a'] if winner=='A' else room['option_b'] if winner=='B' else '무승부'}"
 
+
 async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
     """진행 중인 배틀 목록"""
     async with aiosqlite.connect(db_path) as db:
         db.row_factory = aiosqlite.Row
+        
         cursor = await db.execute(
             """SELECT br.*, 
-            COALESCE(na.username, up.username) as creator_name
-            FROM battle_rooms br
-            LEFT JOIN npc_agents na ON br.creator_agent_id = na.agent_id
-            LEFT JOIN user_profiles up ON br.creator_email = up.email
-            WHERE br.status='active'
-            ORDER BY br.created_at DESC
-            LIMIT ?""",
+                      COALESCE(na.username, up.username) as creator_name
+               FROM battle_rooms br
+               LEFT JOIN npc_agents na ON br.creator_agent_id = na.agent_id
+               LEFT JOIN user_profiles up ON br.creator_email = up.email
+               WHERE br.status='active'
+               ORDER BY br.created_at DESC
+               LIMIT ?""",
             (limit,)
         )
         
@@ -380,6 +381,7 @@ async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
             # 남은 시간
             end_time = datetime.fromisoformat(b['end_time'])
             remaining = end_time - datetime.now()
+            
             if remaining.total_seconds() > 0:
                 if remaining.days > 0:
                     b['time_left'] = f"{remaining.days}일"
@@ -394,19 +396,21 @@ async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
         
         return battles
 
+
 async def auto_resolve_expired_battles(db_path: str):
     """만료된 배틀 자동 판정"""
     async with aiosqlite.connect(db_path) as db:
         cursor = await db.execute(
             """SELECT id FROM battle_rooms 
-            WHERE status='active' AND end_time <= ?""",
+               WHERE status='active' AND end_time <= ?""",
             (datetime.now().isoformat(),)
         )
-        
         expired = await cursor.fetchall()
+        
         for row in expired:
             await resolve_battle(db_path, row[0])
 
+
 # ========== 🤖 NPC 자동 배틀 시스템 ==========
 
 # AI 정체성별 배틀 주제 (다수결 전용)
@@ -483,13 +487,22 @@ BATTLE_TOPICS_BY_IDENTITY = {
     },
 }
 
+
 async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
-    """NPC가 자동으로 배틀방 생성 (AI 정체성 기반)
+    """NPC가 자동으로 배틀방 생성 (AI 정체성 기반, 중복 방지)
     한 번 호출시 1-2개의 배틀방 생성
     """
     results = []
     num_battles = random.randint(1, 2)  # 1-2개 랜덤 생성
     
+    # 🔒 현재 활성화된 배틀방 제목 조회 (중복 방지)
+    async with aiosqlite.connect(db_path) as db:
+        cursor = await db.execute("""
+            SELECT title FROM battle_rooms 
+            WHERE status='active'
+        """)
+        active_titles = {row[0] for row in await cursor.fetchall()}
+    
     for _ in range(num_battles):
         async with aiosqlite.connect(db_path) as db:
             # 활성 NPC 중 GPU 50 이상인 NPC 선택
@@ -497,15 +510,14 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
                 SELECT agent_id, ai_identity, gpu_dollars 
                 FROM npc_agents 
                 WHERE is_active=1 AND gpu_dollars >= 50
-                ORDER BY RANDOM() 
-                LIMIT 1
+                ORDER BY RANDOM() LIMIT 1
             """)
             npc = await cursor.fetchone()
             
             if not npc:
                 results.append("활성 NPC 없음")
                 continue
-            
+                
             agent_id, ai_identity, gpu = npc
             
             # AI 정체성에 맞는 주제 선택
@@ -517,17 +529,31 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
                     ("AGI 언제 올까?", "10년내", "50년후"),
                 ]
             
-            topic = random.choice(topics)
+            # 🎯 중복되지 않는 주제 찾기
+            available_topics = [t for t in topics if t[0] not in active_titles]
+            
+            if not available_topics:
+                results.append(f"⚠️ {agent_id[:8]} 사용 가능한 주제 없음 (모두 활성화됨)")
+                continue
+            
+            # 사용 가능한 주제 중 랜덤 선택
+            topic = random.choice(available_topics)
             title, option_a, option_b = topic
             
             # 배틀방 생성
             success, message, room_id = await create_battle_room(
-                db_path, agent_id, True, title, option_a, option_b, 
+                db_path,
+                agent_id,
+                True,
+                title,
+                option_a,
+                option_b,
                 duration_hours=random.choice([3, 6, 12, 24]),
                 battle_type='opinion'
             )
             
             if success:
+                active_titles.add(title)  # 생성된 제목을 활성 목록에 추가
                 results.append(f"🤖 {agent_id[:8]} 배틀방 생성: {title}")
             else:
                 results.append(message)
@@ -537,6 +563,7 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
     else:
         return False, "배틀방 생성 실패"
 
+
 async def npc_auto_bet(db_path: str) -> int:
     """NPC가 자동으로 배틀에 베팅 (AI 정체성 기반)
     
@@ -550,9 +577,10 @@ async def npc_auto_bet(db_path: str) -> int:
         cursor = await db.execute("""
             SELECT id, title, option_a, option_b, battle_type
             FROM battle_rooms 
-            WHERE status='active' AND battle_type='opinion'
-            AND end_time > ?
-            ORDER BY created_at DESC 
+            WHERE status='active' 
+              AND battle_type='opinion'
+              AND end_time > ?
+            ORDER BY created_at DESC
             LIMIT 10
         """, (datetime.now().isoformat(),))
         battles = await cursor.fetchall()
@@ -566,7 +594,9 @@ async def npc_auto_bet(db_path: str) -> int:
             
             # 이미 베팅한 NPC 제외
             cursor = await db.execute("""
-                SELECT bettor_agent_id FROM battle_bets WHERE room_id=?
+                SELECT bettor_agent_id 
+                FROM battle_bets 
+                WHERE room_id=?
             """, (room_id,))
             already_bet = {row[0] for row in await cursor.fetchall() if row[0]}
             
@@ -575,7 +605,7 @@ async def npc_auto_bet(db_path: str) -> int:
                 SELECT agent_id, ai_identity, mbti, gpu_dollars
                 FROM npc_agents 
                 WHERE is_active=1 AND gpu_dollars >= 1
-                ORDER BY RANDOM() 
+                ORDER BY RANDOM()
                 LIMIT 30
             """)
             npcs = await cursor.fetchall()
@@ -594,13 +624,18 @@ async def npc_auto_bet(db_path: str) -> int:
                 
                 # 베팅 실행
                 success, message = await place_bet(
-                    db_path, room_id, agent_id, True, choice, bet_amount
+                    db_path,
+                    room_id,
+                    agent_id,
+                    True,
+                    choice,
+                    bet_amount
                 )
                 
                 if success:
                     battle_bet_count += 1
                     total_bet_count += 1
-                    
+                
                 # 각 배틀당 최대 8-12명 베팅 (랜덤하게)
                 max_bets_per_battle = random.randint(8, 12)
                 if battle_bet_count >= max_bets_per_battle:
@@ -608,6 +643,7 @@ async def npc_auto_bet(db_path: str) -> int:
     
     return total_bet_count
 
+
 def decide_npc_choice(ai_identity: str, title: str, option_a: str, option_b: str) -> str:
     """AI 정체성에 따라 베팅 선택 결정