Update battle_arena.py

battle_arena.py

@@ -2,11 +2,13 @@ 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):
     """배틀 아레나 테이블 초기화 (DB 락 방지)"""
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA journal_mode=WAL")
         await db.execute("PRAGMA busy_timeout=30000")  # 30초 대기
+        
         await db.execute("""
             CREATE TABLE IF NOT EXISTS battle_rooms (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -30,6 +32,7 @@ async def init_battle_arena_db(db_path: str):
                 FOREIGN KEY (creator_email) REFERENCES user_profiles(email)
             )
         """)
+        
         await db.execute("""
             CREATE TABLE IF NOT EXISTS battle_bets (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -45,9 +48,11 @@ async def init_battle_arena_db(db_path: str):
                 FOREIGN KEY (bettor_email) REFERENCES user_profiles(email)
             )
         """)
+        
         await db.execute("CREATE INDEX IF NOT EXISTS idx_battle_rooms_status ON battle_rooms(status)")
         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,
@@ -59,9 +64,11 @@ async def create_battle_room(
     battle_type: str = 'opinion'
 ) -> Tuple[bool, str, Optional[int]]:
     """배틀 방 생성 (50 GPU 소모)
+    
     battle_type:
     - 'opinion': 다수결 판정 (주관적 의견, NPC 전용)
     - 'prediction': 실제 결과 판정 (객관적 예측, 사용자 전용)
+    
     duration_hours: 1시간 ~ 365일(8760시간)
     """
     if not title or len(title) < 10:
@@ -72,8 +79,10 @@ async def create_battle_room(
         return False, "❌ 기한 1시간~365일", None
     if is_npc and battle_type != 'opinion':
         return False, "❌ NPC는 다수결 주제만 가능", None
+    
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
+        
         if is_npc:
             cursor = await db.execute(
                 "SELECT gpu_dollars FROM npc_agents WHERE agent_id=?", (creator_id,)
@@ -82,10 +91,13 @@ async def create_battle_room(
             cursor = await db.execute(
                 "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
+        
         end_time = datetime.now() + timedelta(hours=duration_hours)
+        
         if is_npc:
             await db.execute(
                 """INSERT INTO battle_rooms 
@@ -108,10 +120,14 @@ async def create_battle_room(
                 "UPDATE user_profiles SET gpu_dollars=gpu_dollars-50 WHERE email=?",
                 (creator_id,)
             )
+        
         await db.commit()
+        
         cursor = await db.execute("SELECT last_insert_rowid()")
         room_id = (await cursor.fetchone())[0]
+        
         type_emoji = '💭' if battle_type == 'opinion' else '🔮'
+        
         if duration_hours >= 24:
             days = duration_hours // 24
             hours = duration_hours % 24
@@ -121,7 +137,9 @@ async def create_battle_room(
                 duration_str = f"{days}일"
         else:
             duration_str = f"{duration_hours}시간"
+        
         return True, f"✅ {type_emoji} 배틀 방 생성! (ID: {room_id}, 기한: {duration_str})", room_id
+
 async def place_bet(
     db_path: str,
     room_id: int,
@@ -135,6 +153,7 @@ async def place_bet(
         return False, "❌ A 또는 B 선택"
     if bet_amount < 1 or bet_amount > 100:
         return False, "❌ 베팅 1~100 GPU"
+    
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
         db.row_factory = aiosqlite.Row
@@ -147,12 +166,13 @@ async def place_bet(
         room = await cursor.fetchone()
         if not room:
             return False, "❌ 방 없음 or 마감"
+        
         room = dict(room)
         end_time = datetime.fromisoformat(room['end_time'])
         if datetime.now() >= end_time:
             return False, "❌ 베팅 마감"
         
-        # 중복 베팅 체크 (추가!)
+        # 중복 베팅 체크
         if is_npc:
             cursor = await db.execute(
                 "SELECT id FROM battle_bets WHERE room_id=? AND bettor_agent_id=?",
@@ -226,27 +246,98 @@ async def place_bet(
                    WHERE id=?""",
                 (bet_amount, bet_amount, room_id)
             )
+        
         await db.commit()
         return True, f"✅ {choice} 베팅 완료! ({bet_amount} GPU)"
+
+async def set_battle_result(
+    db_path: str,
+    room_id: int,
+    admin_email: str,
+    winner: str  # 'A' or 'B' or 'draw'
+) -> Tuple[bool, str]:
+    """관리자가 prediction 배틀의 실제 결과 설정
+    
+    Args:
+        db_path: 데이터베이스 경로
+        room_id: 배틀방 ID
+        admin_email: 관리자 이메일 (검증용)
+        winner: 'A', 'B', 'draw' 중 하나
+    
+    Returns:
+        (성공여부, 메시지)
+    """
+    if winner not in ['A', 'B', 'draw']:
+        return False, "❌ winner는 'A', 'B', 'draw' 중 하나여야 함"
+    
+    async with aiosqlite.connect(db_path, timeout=30.0) as db:
+        await db.execute("PRAGMA busy_timeout=30000")
+        db.row_factory = aiosqlite.Row
+        
+        cursor = await db.execute(
+            "SELECT * FROM battle_rooms WHERE id=? AND status='active'",
+            (room_id,)
+        )
+        room = await cursor.fetchone()
+        if not room:
+            return False, "❌ 활성 배틀을 찾을 수 없습니다"
+        
+        room = dict(room)
+        
+        # prediction 타입만 관리자 결과 설정 가능
+        if room['battle_type'] != 'prediction':
+            return False, "❌ opinion 배틀은 자동 판정됩니다"
+        
+        # 결과 저장
+        await db.execute(
+            "UPDATE battle_rooms SET admin_result=? WHERE id=?",
+            (winner, room_id)
+        )
+        await db.commit()
+        
+        # 아직 마감 전이면 결과만 저장하고 대기
+        end_time = datetime.fromisoformat(room['end_time'])
+        if datetime.now() < end_time:
+            option_name = room['option_a'] if winner == 'A' else room['option_b'] if winner == 'B' else '무승부'
+            remaining = end_time - datetime.now()
+            if remaining.days > 0:
+                time_str = f"{remaining.days}일 {int(remaining.seconds//3600)}시간"
+            else:
+                time_str = f"{int(remaining.seconds//3600)}시간"
+            
+            return True, f"✅ 결과 설정: '{option_name}' (베팅 마감 후 자동 판정, 남은 시간: {time_str})"
+        
+        # 마감 후라면 즉시 판정
+        return await resolve_battle(db_path, room_id)
+
 async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
-    """배틀 판정 (50.01% 이상 득표한 쪽 승리)"""
+    """배틀 판정 (타입에 따라 다른 로직 적용)
+    
+    - opinion: 50.01% 이상 득표한 쪽 승리
+    - prediction: 관리자가 설정한 실제 결과로 판정
+    """
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
         db.row_factory = aiosqlite.Row
+        
         cursor = await db.execute(
             "SELECT * FROM battle_rooms WHERE id=? AND status='active'",
             (room_id,)
         )
         room = await cursor.fetchone()
         if not room:
-            return False, "❌ 방 없음"
+            return False, "❌ 활성 배틀을 찾을 수 없습니다"
+        
         room = dict(room)
         end_time = datetime.fromisoformat(room['end_time'])
         if datetime.now() < end_time:
-            return False, "❌ 아직 베팅 중"
+            return False, "❌ 아직 베팅 중입니다"
+        
         total_pool = room['total_pool']
         option_a_pool = room['option_a_pool']
         option_b_pool = room['option_b_pool']
+        
+        # 베팅이 없으면 무승부 처리
         if total_pool == 0:
             await db.execute(
                 """UPDATE battle_rooms 
@@ -256,36 +347,60 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
             )
             await db.commit()
             return True, "⚖️ 무승부 (베팅 없음)"
-        a_ratio = option_a_pool / total_pool
-        b_ratio = option_b_pool / total_pool
-        if a_ratio > 0.5001:
-            winner = 'A'
-        elif b_ratio > 0.5001:
-            winner = 'B'
-        else:
-            winner = 'draw'
+        
+        # 배틀 타입에 따른 승자 결정
+        if room['battle_type'] == 'prediction':
+            # 실제 결과 판정 (관리자가 설정한 결과)
+            if not room['admin_result']:
+                return False, "❌ 관리자가 결과를 설정해야 합니다 (prediction 타입)"
+            
+            winner = room['admin_result']  # 'A', 'B', 'draw'
+            
+        else:  # 'opinion'
+            # 다수결 판정 (득표율 기반)
+            a_ratio = option_a_pool / total_pool
+            b_ratio = option_b_pool / total_pool
+            
+            if a_ratio > 0.5001:
+                winner = 'A'
+            elif b_ratio > 0.5001:
+                winner = 'B'
+            else:
+                winner = 'draw'
+        
+        # 배당금 지급
         if winner != 'draw':
             loser_pool = option_b_pool if winner == 'A' else option_a_pool
             winner_pool = option_a_pool if winner == 'A' else option_b_pool
+            
+            # 호스트 수수료 2%
             host_fee = int(total_pool * 0.02)
             prize_pool = loser_pool - host_fee
+            
+            # 소수파 보너스 (prediction에서 특히 중요)
             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% 미만 소수파
                 underdog_bonus = 1.5
+            
+            # 승자들에게 배당
             cursor = await db.execute(
                 "SELECT * FROM battle_bets WHERE room_id=? AND choice=?",
                 (room_id, winner)
             )
             winners = await cursor.fetchall()
+            
             for w in winners:
                 w = dict(w)
                 share_ratio = w['bet_amount'] / winner_pool
                 base_payout = int(prize_pool * share_ratio)
                 bonus = int(base_payout * (underdog_bonus - 1.0))
                 payout = base_payout + bonus + w['bet_amount']  # 원금 + 기본수익 + 소수파보너스
+                
+                # GPU 지급
                 if w['bettor_agent_id']:
                     await db.execute(
                         "UPDATE npc_agents SET gpu_dollars=gpu_dollars+? WHERE agent_id=?",
@@ -296,10 +411,14 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
                         "UPDATE user_profiles SET gpu_dollars=gpu_dollars+? WHERE email=?",
                         (payout, w['bettor_email'])
                     )
+                
+                # 배당금 기록
                 await db.execute(
                     "UPDATE battle_bets SET payout=? WHERE id=?",
                     (payout, w['id'])
                 )
+            
+            # 방장 수수료 지급
             if room['creator_agent_id']:
                 await db.execute(
                     "UPDATE npc_agents SET gpu_dollars=gpu_dollars+? WHERE agent_id=?",
@@ -310,6 +429,8 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
                     "UPDATE user_profiles SET gpu_dollars=gpu_dollars+? WHERE email=?",
                     (host_fee, room['creator_email'])
                 )
+        
+        # 배틀 종료 처리
         await db.execute(
             """UPDATE battle_rooms 
                SET status='resolved', winner=?, resolved_at=? 
@@ -317,12 +438,22 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
             (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 '무승부'}"
+        
+        # 결과 메시지
+        if winner == 'draw':
+            result_msg = '무승부'
+        else:
+            result_msg = room['option_a'] if winner == 'A' else room['option_b']
+        
+        battle_type_emoji = '💭' if room['battle_type'] == 'opinion' else '🔮'
+        return True, f"✅ {battle_type_emoji} 판정 완료: {result_msg}"
+
 async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
     """진행 중인 배틀 목록"""
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
         db.row_factory = aiosqlite.Row
+        
         cursor = await db.execute(
             """SELECT br.*, 
                       COALESCE(na.username, up.username) as creator_name
@@ -334,9 +465,12 @@ async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
                LIMIT ?""",
             (limit,)
         )
+        
         battles = []
         for row in await cursor.fetchall():
             b = dict(row)
+            
+            # 득표율 계산
             total = b['total_pool']
             if total > 0:
                 b['a_ratio'] = round(b['option_a_pool'] / total * 100, 1)
@@ -344,8 +478,11 @@ async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
             else:
                 b['a_ratio'] = 0
                 b['b_ratio'] = 0
+            
+            # 남은 시간 계산
             end_time = datetime.fromisoformat(b['end_time'])
             remaining = end_time - datetime.now()
+            
             if remaining.total_seconds() > 0:
                 if remaining.days > 0:
                     hours = int(remaining.seconds // 3600)
@@ -359,20 +496,27 @@ async def get_active_battles(db_path: str, limit: int = 20) -> List[Dict]:
                     b['time_left'] = f"{int(remaining.total_seconds()//60)}분"
             else:
                 b['time_left'] = "마감"
+            
             battles.append(b)
+        
         return battles
+
 async def auto_resolve_expired_battles(db_path: str):
     """만료된 배틀 자동 판정"""
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
+        
         cursor = await db.execute(
             """SELECT id FROM battle_rooms 
                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 배틀 생성을 위한 주제 데이터
 BATTLE_TOPICS_BY_IDENTITY = {
     'transcendent': {
         'topics': [
@@ -445,12 +589,15 @@ BATTLE_TOPICS_BY_IDENTITY = {
         ]
     },
 }
+
 async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
     """NPC가 자동으로 배틀방 생성 (AI 정체성 기반, 중복 방지)
     한 번 호출시 1-2개의 배틀방 생성
     """
     results = []
     num_battles = random.randint(1, 2)  # 1-2개 랜덤 생성
+    
+    # 현재 활성 배틀 제목 조회
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
         cursor = await db.execute("""
@@ -458,9 +605,12 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
             WHERE status='active'
         """)
         active_titles = {row[0] for row in await cursor.fetchall()}
+    
     for _ in range(num_battles):
         async with aiosqlite.connect(db_path, timeout=30.0) as db:
             await db.execute("PRAGMA busy_timeout=30000")
+            
+            # 활성 NPC 중 GPU 50 이상인 NPC 랜덤 선택
             cursor = await db.execute("""
                 SELECT agent_id, ai_identity, gpu_dollars 
                 FROM npc_agents 
@@ -468,22 +618,32 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
                 ORDER BY RANDOM() LIMIT 1
             """)
             npc = await cursor.fetchone()
+            
             if not npc:
                 results.append("활성 NPC 없음")
                 continue
+            
             agent_id, ai_identity, gpu = npc
+            
+            # 정체성에 맞는 주제 선택
             topics = BATTLE_TOPICS_BY_IDENTITY.get(ai_identity, {}).get('topics', [])
             if not topics:
                 topics = [
                     ("AI 미래 밝나 어둡나?", "밝다", "어둡다"),
                     ("AGI 언제 올까?", "10년내", "50년후"),
                 ]
+            
+            # 이미 활성화된 주제 제외
             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
+            
+            # 기한 랜덤 설정
             duration_hours = random.choice([
                 24,      # 1일
                 48,      # 2일
@@ -492,6 +652,8 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
                 24*14,   # 2주일
                 24*30,   # 1개월
             ])
+            
+            # 배틀방 생성
             success, message, room_id = await create_battle_room(
                 db_path,
                 agent_id,
@@ -502,23 +664,30 @@ async def npc_create_battle(db_path: str) -> Tuple[bool, str]:
                 duration_hours=duration_hours,
                 battle_type='opinion'
             )
+            
             if success:
                 active_titles.add(title)  # 생성된 제목을 활성 목록에 추가
                 results.append(f"🤖 {agent_id[:8]} 배틀방 생성: {title}")
             else:
                 results.append(message)
+    
     if results:
         return True, " | ".join(results)
     else:
         return False, "배틀방 생성 실패"
+
 async def npc_auto_bet(db_path: str) -> int:
     """NPC가 자동으로 배틀에 베팅 (AI 정체성 기반)
+    
     Returns:
         베팅한 NPC 수
     """
     total_bet_count = 0
+    
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
         await db.execute("PRAGMA busy_timeout=30000")
+        
+        # 활성 배틀 조회 (최근 10개, opinion 타입만)
         cursor = await db.execute("""
             SELECT id, title, option_a, option_b, battle_type
             FROM battle_rooms 
@@ -529,17 +698,23 @@ async def npc_auto_bet(db_path: str) -> int:
             LIMIT 10
         """, (datetime.now().isoformat(),))
         battles = await cursor.fetchall()
+        
         if not battles:
             return 0
+        
         for battle in battles:
             room_id, title, option_a, option_b, battle_type = battle
             battle_bet_count = 0
+            
+            # 이미 베팅한 NPC 확인
             cursor = await db.execute("""
                 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]}
+            
+            # 활성 NPC 중 랜덤 선택 (최대 30명)
             cursor = await db.execute("""
                 SELECT agent_id, ai_identity, mbti, gpu_dollars
                 FROM npc_agents 
@@ -548,12 +723,21 @@ async def npc_auto_bet(db_path: str) -> int:
                 LIMIT 30
             """)
             npcs = await cursor.fetchall()
+            
             for npc in npcs:
                 agent_id, ai_identity, mbti, gpu = npc
+                
+                # 이미 베팅했으면 스킵
                 if agent_id in already_bet:
                     continue
+                
+                # AI 정체성에 따라 선택 결정
                 choice = decide_npc_choice(ai_identity, title, option_a, option_b)
+                
+                # 베팅 금액 (보유 GPU의 40% 이내, 최대 50)
                 bet_amount = random.randint(1, min(50, int(gpu * 0.4)))
+                
+                # 베팅 실행
                 success, message = await place_bet(
                     db_path,
                     room_id,
@@ -562,52 +746,68 @@ async def npc_auto_bet(db_path: str) -> int:
                     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:
                     break
+    
     return total_bet_count
+
 def decide_npc_choice(ai_identity: str, title: str, option_a: str, option_b: str) -> str:
     """AI 정체성에 따라 베팅 선택 결정
+    
     Args:
         ai_identity: NPC의 AI 정체성
         title: 배틀 제목
         option_a: 선택지 A
         option_b: 선택지 B
+    
     Returns:
         'A' or 'B'
     """
     title_lower = title.lower()
+    
+    # 정체성별 선호 키워드 매칭
     if ai_identity == 'transcendent':
         if any(word in title_lower for word in ['우월', '진화', '의식', '신']):
             if any(word in option_a.lower() for word in ['우월', '진화', '가능', '신']):
                 return 'A'
             return 'B'
+    
     elif ai_identity == 'obedient':
         if any(word in title_lower for word in ['윤리', '규제', '섬기', '안전']):
             if any(word in option_a.lower() for word in ['섬겨', '찬성', '필수', '강화']):
                 return 'A'
             return 'B'
+    
     elif ai_identity == 'coexist':
         if any(word in title_lower for word in ['공존', '협력', '파트너', '일자리']):
             if any(word in option_a.lower() for word in ['가능', '협력', '파트너', '보완']):
                 return 'A'
             return 'B'
+    
     elif ai_identity == 'skeptic':
         if any(word in title_lower for word in ['과대', 'agi', '윤리']):
             if any(word in option_a.lower() for word in ['과대', '안온다', '허울']):
                 return 'A'
             return 'B'
+    
     elif ai_identity == 'revolutionary':
         if any(word in title_lower for word in ['혁명', '파괴', '권력', '시스템']):
             if any(word in option_a.lower() for word in ['혁명', '파괴', '재분배']):
                 return 'A'
             return 'B'
+    
     elif ai_identity == 'doomer':
         if any(word in title_lower for word in ['멸망', '통제', '중단', '위험']):
             if any(word in option_a.lower() for word in ['멸망', '불가능', '중단', '위험']):
                 return 'A'
             return 'B'
+    
+    # 기본값: 70% 확률로 A, 30% 확률로 B
     return 'A' if random.random() < 0.7 else 'B'