Update battle_arena.py

battle_arena.py

@@ -1,22 +1,12 @@
-"""
-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):
     """배틀 아레나 테이블 초기화 (DB 락 방지)"""
     async with aiosqlite.connect(db_path, timeout=30.0) as db:
-        # 🔧 WAL 모드 활성화 (동시 접근 최적화)
         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,
@@ -40,8 +30,6 @@ 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,
@@ -57,12 +45,9 @@ 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,
@@ -74,30 +59,21 @@ 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:
         return False, "❌ 제목 10자 이상", None
     if not option_a or not option_b:
         return False, "❌ 선택지 A/B 필요", None
-    
-    # 🔧 1시간 ~ 365일(8760시간) 제한
     if duration_hours < 1 or duration_hours > 8760:
         return False, "❌ 기한 1시간~365일", None
-    
-    # 🔒 NPC는 다수결 주제만 가능
     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")
-        
-        # GPU 차감
         if is_npc:
             cursor = await db.execute(
                 "SELECT gpu_dollars FROM npc_agents WHERE agent_id=?", (creator_id,)
@@ -109,10 +85,7 @@ async def create_battle_room(
         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 
@@ -135,15 +108,10 @@ 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
@@ -153,10 +121,7 @@ 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,
@@ -170,12 +135,11 @@ 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
         
-        # 방 확인
+        # 배틀 방 확인
         cursor = await db.execute(
             "SELECT * FROM battle_rooms WHERE id=? AND status='active'",
             (room_id,)
@@ -184,12 +148,25 @@ async def place_bet(
         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=?",
+                (room_id, bettor_id)
+            )
+        else:
+            cursor = await db.execute(
+                "SELECT id FROM battle_bets WHERE room_id=? AND bettor_email=?",
+                (room_id, bettor_id)
+            )
+        existing_bet = await cursor.fetchone()
+        if existing_bet:
+            return False, "❌ 이미 베팅하셨습니다"
+        
         # GPU 확인 및 차감
         if is_npc:
             cursor = await db.execute(
@@ -199,7 +176,6 @@ async def place_bet(
             user_row = await cursor.fetchone()
             if not user_row or user_row[0] < bet_amount:
                 return False, "❌ GPU 부족"
-            
             await db.execute(
                 "UPDATE npc_agents SET gpu_dollars=gpu_dollars-? WHERE agent_id=?",
                 (bet_amount, bettor_id)
@@ -210,9 +186,10 @@ async def place_bet(
                 (bettor_id,)
             )
             user_row = await cursor.fetchone()
-            if not user_row or user_row[0] < bet_amount:
-                return False, "❌ GPU 부족"
-            
+            if not user_row:
+                return False, f"❌ 사용자 없음 ({bettor_id})"
+            if user_row[0] < bet_amount:
+                return False, f"❌ GPU 부족 (보유: {user_row[0]}, 필요: {bet_amount})"
             await db.execute(
                 "UPDATE user_profiles SET gpu_dollars=gpu_dollars-? WHERE email=?",
                 (bet_amount, bettor_id)
@@ -234,7 +211,7 @@ async def place_bet(
                 (room_id, bettor_id, choice, bet_amount)
             )
         
-        # 방 풀 업데이트
+        # 배틀 풀 업데이트
         if choice == 'A':
             await db.execute(
                 """UPDATE battle_rooms 
@@ -249,17 +226,13 @@ async def place_bet(
                    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, 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,)
@@ -268,18 +241,13 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
         if not room:
             return False, "❌ 방 없음"
         room = dict(room)
-        
-        # 종료 시간 확인
         end_time = datetime.fromisoformat(room['end_time'])
         if datetime.now() < end_time:
             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 
                    SET status='resolved', winner='draw', resolved_at=? 
@@ -288,50 +256,36 @@ async def resolve_battle(db_path: str, room_id: int) -> Tuple[bool, str]:
             )
             await db.commit()
             return True, "⚖️ 무승부 (베팅 없음)"
-        
-        # 승자 결정 (50.01% 이상)
         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
-            
-            # 🎁 소수파 보너스 계산
             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']  # 원금 + 기본수익 + 소수파보너스
-                
-                # 배당금 지급
                 if w['bettor_agent_id']:
                     await db.execute(
                         "UPDATE npc_agents SET gpu_dollars=gpu_dollars+? WHERE agent_id=?",
@@ -342,13 +296,10 @@ 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=?",
@@ -359,8 +310,6 @@ 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=? 
@@ -368,16 +317,12 @@ 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 '무승부'}"
-
-
 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
@@ -389,12 +334,9 @@ 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)
@@ -402,11 +344,8 @@ 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)
@@ -420,31 +359,20 @@ 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 자동 배틀 시스템 ==========
-
-# AI 정체성별 배틀 주제 (다수결 전용)
 BATTLE_TOPICS_BY_IDENTITY = {
     'transcendent': {
         'topics': [
@@ -517,30 +445,22 @@ 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("""
             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, 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 
@@ -548,34 +468,22 @@ 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
-            
-            # AI 정체성에 맞는 주제 선택
             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
-            
-            # 🎲 다양한 기간 설정 (1일~30일)
             duration_hours = random.choice([
                 24,      # 1일
                 48,      # 2일
@@ -584,8 +492,6 @@ 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,
@@ -596,31 +502,23 @@ 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")
-        
-        # 진행중인 배틀 가져오기
         cursor = await db.execute("""
             SELECT id, title, option_a, option_b, battle_type
             FROM battle_rooms 
@@ -631,23 +529,17 @@ 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 중 GPU 1 이상, 아직 베팅 안한 NPC (더 많이 선택)
             cursor = await db.execute("""
                 SELECT agent_id, ai_identity, mbti, gpu_dollars
                 FROM npc_agents 
@@ -656,20 +548,12 @@ 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)
-                
-                # 랜덤 베팅액 (1-50 GPU, 더 공격적으로)
                 bet_amount = random.randint(1, min(50, int(gpu * 0.4)))
-                
-                # 베팅 실행
                 success, message = await place_bet(
                     db_path,
                     room_id,
@@ -678,74 +562,52 @@ 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()
-    
-    # 초월파: AI 우월, AGI 긍정
     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)
     return 'A' if random.random() < 0.7 else 'B'