Create app.py

app.py

@@ -0,0 +1,902 @@
+"""
+Life Frontier: Partner's Concerto
+Single-app turn-based game with SQLite state management
+"""
+
+import gradio as gr
+import sqlite3
+import json
+import random
+import time
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass, asdict
+from enum import Enum
+import threading
+
+# ===== CONSTANTS =====
+INITIAL_TIME = 24
+INITIAL_HP = 10
+INITIAL_CP = 5
+INITIAL_MONEY = 10
+STRESS_THRESHOLD = 20
+DB_PATH = "game.db"
+
+# ===== DATA MODELS =====
+class CardType(str, Enum):
+    WORK = "W"
+    DOMESTIC = "D"
+    HEALTH = "H"
+    RELATIONSHIP = "R"
+    SOCIAL = "S"
+    QOL = "Q"
+
+@dataclass
+class PlayerState:
+    player_id: str
+    name: str
+    character_id: str
+    time: int = INITIAL_TIME
+    hp: int = INITIAL_HP
+    cp: int = INITIAL_CP
+    money: int = INITIAL_MONEY
+    stress: int = 0
+    qol: int = 0
+    reputation: int = 0
+    hp_max: int = INITIAL_HP
+    cp_max: int = INITIAL_CP
+    is_eliminated: bool = False
+    has_ended_turn: bool = False
+    completed_tasks: str = ""  # JSON array
+    
+    def to_dict(self):
+        return asdict(self)
+    
+    def calculate_final_qol(self) -> int:
+        if self.is_eliminated:
+            return 0
+        hp_bonus = (self.hp_max - INITIAL_HP) * 2
+        cp_bonus = (self.cp_max - INITIAL_CP) * 3
+        return self.qol + hp_bonus + cp_bonus + self.reputation - self.stress
+
+@dataclass
+class GameState:
+    room_id: str
+    current_round: int = 1
+    total_rounds: int = 8
+    current_turn: int = 0  # 0=player1, 1=player2
+    status: str = "waiting"  # waiting, playing, finished
+    available_tasks: str = ""  # JSON array of task IDs
+    active_negotiation: str = ""  # JSON negotiation data
+    created_at: str = ""
+    
+# ===== DATABASE MANAGEMENT =====
+class GameDatabase:
+    def __init__(self, db_path: str = DB_PATH):
+        self.db_path = db_path
+        self.lock = threading.Lock()
+        self.init_db()
+    
+    def get_connection(self):
+        conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        conn.row_factory = sqlite3.Row
+        return conn
+    
+    def init_db(self):
+        with self.lock, self.get_connection() as conn:
+            # Rooms table
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS rooms (
+                    room_id TEXT PRIMARY KEY,
+                    current_round INTEGER DEFAULT 1,
+                    total_rounds INTEGER DEFAULT 8,
+                    current_turn INTEGER DEFAULT 0,
+                    status TEXT DEFAULT 'waiting',
+                    available_tasks TEXT DEFAULT '[]',
+                    active_negotiation TEXT DEFAULT '',
+                    created_at TEXT,
+                    winner_id TEXT
+                )
+            """)
+            
+            # Players table
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS players (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    room_id TEXT,
+                    player_id TEXT,
+                    name TEXT,
+                    character_id TEXT,
+                    player_slot INTEGER,
+                    time INTEGER DEFAULT 24,
+                    hp INTEGER DEFAULT 10,
+                    cp INTEGER DEFAULT 5,
+                    money INTEGER DEFAULT 10,
+                    stress INTEGER DEFAULT 0,
+                    qol INTEGER DEFAULT 0,
+                    reputation INTEGER DEFAULT 0,
+                    hp_max INTEGER DEFAULT 10,
+                    cp_max INTEGER DEFAULT 5,
+                    is_eliminated INTEGER DEFAULT 0,
+                    has_ended_turn INTEGER DEFAULT 0,
+                    completed_tasks TEXT DEFAULT '[]',
+                    UNIQUE(room_id, player_slot)
+                )
+            """)
+            
+            # Spectators table
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS spectators (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    room_id TEXT,
+                    spectator_id TEXT,
+                    name TEXT,
+                    joined_at TEXT
+                )
+            """)
+            
+            # Rankings table
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS rankings (
+                    player_name TEXT PRIMARY KEY,
+                    total_games INTEGER DEFAULT 0,
+                    total_wins INTEGER DEFAULT 0,
+                    highest_qol INTEGER DEFAULT 0,
+                    average_qol REAL DEFAULT 0.0,
+                    last_played TEXT
+                )
+            """)
+            
+            # Game history
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS game_history (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    room_id TEXT,
+                    player1_name TEXT,
+                    player2_name TEXT,
+                    winner_name TEXT,
+                    player1_qol INTEGER,
+                    player2_qol INTEGER,
+                    total_rounds INTEGER,
+                    completed_at TEXT
+                )
+            """)
+            
+            conn.commit()
+    
+    def create_room(self, room_id: str, total_rounds: int = 8) -> bool:
+        with self.lock, self.get_connection() as conn:
+            try:
+                conn.execute("""
+                    INSERT INTO rooms (room_id, total_rounds, created_at, status)
+                    VALUES (?, ?, ?, 'waiting')
+                """, (room_id, total_rounds, datetime.now().isoformat()))
+                conn.commit()
+                return True
+            except sqlite3.IntegrityError:
+                return False
+    
+    def join_room(self, room_id: str, player_id: str, name: str, 
+                  character_id: str) -> Tuple[bool, Optional[int], str]:
+        """Returns (success, player_slot, message)"""
+        with self.lock, self.get_connection() as conn:
+            # Check room exists
+            room = conn.execute(
+                "SELECT status FROM rooms WHERE room_id = ?", (room_id,)
+            ).fetchone()
+            
+            if not room:
+                return False, None, "Room not found"
+            
+            if room['status'] != 'waiting':
+                # Game already started, join as spectator
+                conn.execute("""
+                    INSERT INTO spectators (room_id, spectator_id, name, joined_at)
+                    VALUES (?, ?, ?, ?)
+                """, (room_id, player_id, name, datetime.now().isoformat()))
+                conn.commit()
+                return True, None, f"Joined as spectator. Game in progress."
+            
+            # Try to join as player
+            players = conn.execute(
+                "SELECT player_slot FROM players WHERE room_id = ?", (room_id,)
+            ).fetchall()
+            
+            if len(players) >= 2:
+                # Room full, join as spectator
+                conn.execute("""
+                    INSERT INTO spectators (room_id, spectator_id, name, joined_at)
+                    VALUES (?, ?, ?, ?)
+                """, (room_id, player_id, name, datetime.now().isoformat()))
+                conn.commit()
+                return True, None, f"Room full. Joined as spectator."
+            
+            # Join as player
+            slot = 0 if len(players) == 0 else 1
+            conn.execute("""
+                INSERT INTO players (
+                    room_id, player_id, name, character_id, player_slot
+                ) VALUES (?, ?, ?, ?, ?)
+            """, (room_id, player_id, name, character_id, slot))
+            conn.commit()
+            
+            # If 2 players, start game
+            if slot == 1:
+                self._start_game(room_id, conn)
+            
+            return True, slot, f"Joined as Player {slot + 1}"
+    
+    def _start_game(self, room_id: str, conn):
+        """Internal: Start game when 2 players joined"""
+        # Update room status
+        conn.execute("""
+            UPDATE rooms SET status = 'playing' WHERE room_id = ?
+        """, (room_id,))
+        
+        # Draw initial tasks (3 random)
+        task_ids = random.sample([t['id'] for t in TASKS], 3)
+        conn.execute("""
+            UPDATE rooms SET available_tasks = ? WHERE room_id = ?
+        """, (json.dumps(task_ids), room_id))
+        
+        conn.commit()
+    
+    def get_room_state(self, room_id: str) -> Optional[Dict]:
+        """Get complete room state including players"""
+        with self.lock, self.get_connection() as conn:
+            room = conn.execute(
+                "SELECT * FROM rooms WHERE room_id = ?", (room_id,)
+            ).fetchone()
+            
+            if not room:
+                return None
+            
+            players = conn.execute("""
+                SELECT * FROM players WHERE room_id = ? ORDER BY player_slot
+            """, (room_id,)).fetchall()
+            
+            spectators = conn.execute("""
+                SELECT name FROM spectators WHERE room_id = ?
+            """, (room_id,)).fetchall()
+            
+            return {
+                'room': dict(room),
+                'players': [dict(p) for p in players],
+                'spectators': [s['name'] for s in spectators],
+                'task_ids': json.loads(room['available_tasks'] or '[]')
+            }
+    
+    def update_player(self, room_id: str, player_slot: int, updates: Dict):
+        """Update player state"""
+        with self.lock, self.get_connection() as conn:
+            set_clause = ", ".join([f"{k} = ?" for k in updates.keys()])
+            values = list(updates.values()) + [room_id, player_slot]
+            
+            conn.execute(f"""
+                UPDATE players SET {set_clause}
+                WHERE room_id = ? AND player_slot = ?
+            """, values)
+            conn.commit()
+    
+    def end_turn(self, room_id: str, player_slot: int):
+        """End player's turn and check for round end"""
+        with self.lock, self.get_connection() as conn:
+            # Mark turn ended
+            conn.execute("""
+                UPDATE players SET has_ended_turn = 1
+                WHERE room_id = ? AND player_slot = ?
+            """, (room_id, player_slot))
+            
+            # Check if both ended turn
+            count = conn.execute("""
+                SELECT COUNT(*) as cnt FROM players
+                WHERE room_id = ? AND has_ended_turn = 1
+            """, (room_id,)).fetchone()['cnt']
+            
+            if count == 2:
+                # Both ended, advance round
+                self._advance_round(room_id, conn)
+            else:
+                # Switch turn
+                room = conn.execute(
+                    "SELECT current_turn FROM rooms WHERE room_id = ?", (room_id,)
+                ).fetchone()
+                next_turn = 1 - room['current_turn']
+                conn.execute("""
+                    UPDATE rooms SET current_turn = ? WHERE room_id = ?
+                """, (next_turn, room_id))
+            
+            conn.commit()
+    
+    def _advance_round(self, room_id: str, conn):
+        """Internal: Advance to next round"""
+        room = conn.execute(
+            "SELECT current_round, total_rounds FROM rooms WHERE room_id = ?",
+            (room_id,)
+        ).fetchone()
+        
+        next_round = room['current_round'] + 1
+        
+        if next_round > room['total_rounds']:
+            # Game over
+            self._end_game(room_id, conn)
+        else:
+            # Reset for next round
+            conn.execute("""
+                UPDATE players SET 
+                    time = ?, has_ended_turn = 0, completed_tasks = '[]'
+                WHERE room_id = ?
+            """, (INITIAL_TIME, room_id))
+            
+            # Draw new tasks
+            task_ids = random.sample([t['id'] for t in TASKS], 3)
+            conn.execute("""
+                UPDATE rooms SET 
+                    current_round = ?, 
+                    current_turn = 0,
+                    available_tasks = ?
+                WHERE room_id = ?
+            """, (next_round, json.dumps(task_ids), room_id))
+    
+    def _end_game(self, room_id: str, conn):
+        """Internal: End game and calculate winner"""
+        players = conn.execute("""
+            SELECT * FROM players WHERE room_id = ? ORDER BY player_slot
+        """, (room_id,)).fetchall()
+        
+        # Calculate final QoL
+        p1 = PlayerState(**{k: players[0][k] for k in players[0].keys() 
+                            if k in PlayerState.__annotations__})
+        p2 = PlayerState(**{k: players[1][k] for k in players[1].keys() 
+                            if k in PlayerState.__annotations__})
+        
+        qol1 = p1.calculate_final_qol()
+        qol2 = p2.calculate_final_qol()
+        
+        winner_id = p1.player_id if qol1 > qol2 else p2.player_id
+        winner_name = p1.name if qol1 > qol2 else p2.name
+        
+        # Update room
+        conn.execute("""
+            UPDATE rooms SET status = 'finished', winner_id = ?
+            WHERE room_id = ?
+        """, (winner_id, room_id))
+        
+        # Save to history
+        conn.execute("""
+            INSERT INTO game_history (
+                room_id, player1_name, player2_name, winner_name,
+                player1_qol, player2_qol, total_rounds, completed_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """, (room_id, p1.name, p2.name, winner_name, qol1, qol2,
+              players[0]['completed_tasks'], datetime.now().isoformat()))
+        
+        # Update rankings
+        self._update_rankings(p1.name, qol1, winner_name == p1.name, conn)
+        self._update_rankings(p2.name, qol2, winner_name == p2.name, conn)
+    
+    def _update_rankings(self, player_name: str, qol: int, won: bool, conn):
+        """Internal: Update player rankings"""
+        existing = conn.execute("""
+            SELECT * FROM rankings WHERE player_name = ?
+        """, (player_name,)).fetchone()
+        
+        if existing:
+            new_games = existing['total_games'] + 1
+            new_wins = existing['total_wins'] + (1 if won else 0)
+            new_avg = ((existing['average_qol'] * existing['total_games']) + qol) / new_games
+            new_high = max(existing['highest_qol'], qol)
+            
+            conn.execute("""
+                UPDATE rankings SET
+                    total_games = ?, total_wins = ?,
+                    average_qol = ?, highest_qol = ?,
+                    last_played = ?
+                WHERE player_name = ?
+            """, (new_games, new_wins, new_avg, new_high,
+                  datetime.now().isoformat(), player_name))
+        else:
+            conn.execute("""
+                INSERT INTO rankings (
+                    player_name, total_games, total_wins,
+                    average_qol, highest_qol, last_played
+                ) VALUES (?, 1, ?, ?, ?, ?)
+            """, (player_name, 1 if won else 0, qol, qol,
+                  datetime.now().isoformat()))
+    
+    def get_rankings(self, limit: int = 10) -> List[Dict]:
+        """Get top rankings"""
+        with self.get_connection() as conn:
+            rows = conn.execute("""
+                SELECT 
+                    player_name, total_games, total_wins,
+                    ROUND(average_qol, 1) as avg_qol,
+                    highest_qol,
+                    ROUND(CAST(total_wins AS REAL) / total_games * 100, 1) as win_rate
+                FROM rankings
+                WHERE total_games > 0
+                ORDER BY average_qol DESC
+                LIMIT ?
+            """, (limit,)).fetchall()
+            return [dict(r) for r in rows]
+
+# ===== GAME DATA =====
+CHARACTERS = [
+    {"id": "P1", "name": "Workaholic", "desc": "Work +2 VP, but +1 stress/turn"},
+    {"id": "P4", "name": "Hedonist", "desc": "QoL +1, but domestic +2 time"},
+    {"id": "R3", "name": "Planner", "desc": "Can force round-up in negotiation"},
+    {"id": "H3", "name": "Fitness Buff", "desc": "Rest +1 HP, HP max +2"},
+]
+
+TASKS = [
+    {"id": "W1", "name": "Core Project", "type": "W", "time": 8, 
+     "solo": {"CP": 7, "HP": 3}, "coop": {"CP": 10}, "reward": 12},
+    {"id": "W2", "name": "Annual Report", "type": "W", "time": 6,
+     "solo": {"CP": 6}, "coop": {"CP": 8}, "reward": 8},
+    {"id": "D1", "name": "Deep Clean Kitchen", "type": "D", "time": 5,
+     "solo": {"HP": 5}, "coop": {"HP": 7}, "reward": 0, "effect": "stress:-2"},
+    {"id": "D2", "name": "Laundry & Organize", "type": "D", "time": 3,
+     "solo": {"HP": 3}, "coop": {"HP": 4}, "reward": 0, "effect": "hp:+2"},
+    {"id": "H1", "name": "Fitness Training", "type": "H", "time": 5,
+     "solo": {"HP": 6}, "coop": {"HP": 8}, "reward": 1, "effect": "hp_max:+1"},
+    {"id": "R1", "name": "Romantic Date", "type": "R", "time": 5,
+     "solo": {"CP": 5}, "coop": {"CP": 7}, "cost": 5, "qol": 3, "effect": "stress:-3"},
+    {"id": "Q2", "name": "Weekend Trip", "type": "Q", "time": 7,
+     "solo": {"HP": 5, "CP": 4}, "coop": {"HP": 9}, "cost": 15, "qol": 7, "effect": "recover_all"},
+]
+
+# ===== GLOBAL STATE =====
+db = GameDatabase()
+
+# ===== GAME LOGIC =====
+def roll_dice() -> int:
+    return random.randint(1, 6)
+
+def execute_rest(player: Dict, rest_type: str) -> Tuple[bool, str, Dict]:
+    """Execute rest action"""
+    if rest_type == "quick_nap":
+        if player['time'] < 3:
+            return False, "Not enough time (need 3h)", {}
+        dice = roll_dice()
+        hp_recovered = 2 * dice
+        new_hp = min(player['hp'] + hp_recovered, player['hp_max'])
+        return True, f"Rolled {dice}! Recovered {hp_recovered} HP", {
+            'time': player['time'] - 3,
+            'hp': new_hp
+        }
+    
+    elif rest_type == "full_sleep":
+        if player['time'] < 9:
+            return False, "Not enough time (need 9h)", {}
+        return True, "Recovered to base levels and reduced stress", {
+            'time': player['time'] - 9,
+            'hp': min(8, player['hp_max']),
+            'cp': min(4, player['cp_max']),
+            'stress': max(0, player['stress'] - 1)
+        }
+    
+    elif rest_type == "deep_rest":
+        if player['time'] < 12:
+            return False, "Not enough time (need 12h)", {}
+        return True, "Full recovery!", {
+            'time': player['time'] - 12,
+            'hp': player['hp_max'],
+            'cp': player['cp_max'],
+            'stress': max(0, player['stress'] - 2)
+        }
+    
+    return False, "Invalid rest type", {}
+
+def execute_solo_task(player: Dict, task: Dict) -> Tuple[bool, str, Dict]:
+    """Execute task solo"""
+    # Check requirements
+    solo_req = task['solo']
+    if player['time'] < task['time']:
+        return False, f"Not enough time (need {task['time']}h)", {}
+    
+    for res, amount in solo_req.items():
+        if res == "HP" and player['hp'] < amount:
+            return False, f"Not enough HP (need {amount})", {}
+        if res == "CP" and player['cp'] < amount:
+            return False, f"Not enough CP (need {amount})", {}
+    
+    # Check cost
+    if 'cost' in task and player['money'] < task['cost']:
+        return False, f"Not enough money (need ${task['cost']})", {}
+    
+    # Execute
+    updates = {
+        'time': player['time'] - task['time'],
+        'stress': player['stress'] + 1  # Fatigue
+    }
+    
+    # Spend resources
+    if 'HP' in solo_req:
+        updates['hp'] = player['hp'] - solo_req['HP']
+    if 'CP' in solo_req:
+        updates['cp'] = player['cp'] - solo_req['CP']
+    if 'cost' in task:
+        updates['money'] = player['money'] - task['cost']
+    
+    # Apply rewards
+    if 'reward' in task:
+        updates['money'] = updates.get('money', player['money']) + task['reward']
+    if 'qol' in task:
+        updates['qol'] = player['qol'] + task['qol']
+    
+    # Apply effects
+    if 'effect' in task:
+        for effect in task['effect'].split(','):
+            if ':' in effect:
+                eff_type, value = effect.split(':')
+                value = int(value)
+                if eff_type == 'stress':
+                    updates['stress'] = max(0, updates.get('stress', player['stress']) + value)
+                elif eff_type == 'hp':
+                    updates['hp'] = min(updates.get('hp', player['hp']) + value, player['hp_max'])
+                elif eff_type == 'hp_max':
+                    updates['hp_max'] = player['hp_max'] + value
+            elif effect == 'recover_all':
+                updates['hp'] = player['hp_max']
+                updates['cp'] = player['cp_max']
+    
+    # Check elimination
+    if updates.get('stress', player['stress']) >= STRESS_THRESHOLD:
+        updates['is_eliminated'] = 1
+        return True, f"⚠️ Task completed but ELIMINATED (stress {updates['stress']})", updates
+    
+    msg = f"✓ {task['name']} completed!"
+    if 'reward' in task:
+        msg += f" +${task['reward']}"
+    if 'qol' in task:
+        msg += f" +{task['qol']} QoL"
+    
+    return True, msg, updates
+
+# ===== GRADIO UI =====
+def create_ui():
+    with gr.Blocks(title="Life Frontier: Partner's Concerto", theme=gr.themes.Soft()) as app:
+        gr.Markdown("""
+        # 🏠 Life Frontier: Partner's Concerto
+        *A turn-based strategy game for couples*
+        """)
+        
+        # Session state
+        session_state = gr.State({
+            'room_id': None,
+            'player_id': None,
+            'player_slot': None,
+            'is_spectator': False
+        })
+        
+        with gr.Tab("🎮 Join/Create Game"):
+            with gr.Row():
+                room_id_input = gr.Textbox(label="Room ID", placeholder="Leave empty to create new")
+                your_name_input = gr.Textbox(label="Your Name", value="Player")
+            
+            character_select = gr.Dropdown(
+                choices=[(c['name'], c['id']) for c in CHARACTERS],
+                label="Select Character",
+                value=CHARACTERS[0]['id']
+            )
+            
+            with gr.Row():
+                create_btn = gr.Button("🆕 Create Room", variant="primary")
+                join_btn = gr.Button("🚪 Join Room", variant="secondary")
+            
+            join_result = gr.Markdown()
+        
+        with gr.Tab("🎯 Game Board"):
+            gr.Markdown("### Game Status")
+            status_display = gr.Markdown("*No game joined*")
+            
+            with gr.Row():
+                # Player 1 Panel
+                with gr.Column():
+                    gr.Markdown("### Player 1")
+                    p1_display = gr.JSON(label="Status")
+                
+                # Center - Actions
+                with gr.Column():
+                    gr.Markdown("### Your Actions")
+                    your_turn_msg = gr.Markdown("*Waiting for your turn...*")
+                    
+                    gr.Markdown("**Rest Actions**")
+                    with gr.Row():
+                        quick_nap_btn = gr.Button("Quick Nap (3h)")
+                        full_sleep_btn = gr.Button("Full Sleep (9h)")
+                        deep_rest_btn = gr.Button("Deep Rest (12h)")
+                    
+                    gr.Markdown("**Available Tasks**")
+                    tasks_display = gr.Dataframe(
+                        headers=["ID", "Name", "Type", "Time", "Requirements", "Reward"],
+                        label="Public Tasks"
+                    )
+                    
+                    task_select = gr.Dropdown(label="Select Task")
+                    solo_task_btn = gr.Button("Execute Solo Task", variant="primary")
+                    
+                    end_turn_btn = gr.Button("⏭️ End Turn", variant="secondary")
+                    
+                    action_result = gr.Markdown()
+                
+                # Player 2 Panel
+                with gr.Column():
+                    gr.Markdown("### Player 2")
+                    p2_display = gr.JSON(label="Status")
+            
+            gr.Markdown("### Spectators")
+            spectators_display = gr.Markdown("*No spectators*")
+            
+            refresh_btn = gr.Button("🔄 Refresh Game State")
+        
+        with gr.Tab("🏆 Rankings"):
+            rankings_table = gr.Dataframe(
+                headers=["Rank", "Player", "Avg QoL", "Games", "Wins", "Win %"],
+                label="Top Players"
+            )
+            refresh_rankings_btn = gr.Button("🔄 Refresh Rankings")
+        
+        # ===== EVENT HANDLERS =====
+        
+        def create_room_handler(your_name, character_id):
+            import uuid
+            room_id = str(uuid.uuid4())[:8].upper()
+            player_id = str(uuid.uuid4())[:8]
+            
+            db.create_room(room_id)
+            success, slot, msg = db.join_room(room_id, player_id, your_name, character_id)
+            
+            if success:
+                return {
+                    'room_id': room_id,
+                    'player_id': player_id,
+                    'player_slot': slot,
+                    'is_spectator': slot is None
+                }, f"✅ Room created: **{room_id}**\n\n{msg}\n\nShare this Room ID with your partner!"
+            return {}, f"❌ Failed to create room: {msg}"
+        
+        def join_room_handler(room_id, your_name, character_id):
+            import uuid
+            player_id = str(uuid.uuid4())[:8]
+            
+            success, slot, msg = db.join_room(room_id, player_id, your_name, character_id)
+            
+            if success:
+                return {
+                    'room_id': room_id,
+                    'player_id': player_id,
+                    'player_slot': slot,
+                    'is_spectator': slot is None
+                }, f"✅ {msg}"
+            return {}, f"❌ {msg}"
+        
+        def refresh_game_state(session):
+            if not session.get('room_id'):
+                return ("*No game joined*", {}, {}, [], "*No spectators*", "")
+            
+            state = db.get_room_state(session['room_id'])
+            if not state:
+                return ("*Room not found*", {}, {}, [], "*No spectators*", "")
+            
+            room = state['room']
+            players = state['players']
+            
+            # Status
+            status_md = f"""
+            **Room:** {session['room_id']} | **Round:** {room['current_round']}/{room['total_rounds']}
+            **Status:** {room['status'].upper()} | **Current Turn:** Player {room['current_turn'] + 1}
+            """
+            
+            if room['status'] == 'finished':
+                status_md += f"\n\n🏆 **GAME OVER!** Winner: {room['winner_id']}"
+            
+            # Players
+            p1_data = players[0] if len(players) > 0 else {}
+            p2_data = players[1] if len(players) > 1 else {}
+            
+            # Tasks
+            task_rows = []
+            for task_id in state['task_ids']:
+                task = next((t for t in TASKS if t['id'] == task_id), None)
+                if task:
+                    req_str = ', '.join([f"{k}:{v}" for k, v in task['solo'].items()])
+                    reward_str = f"${task.get('reward', 0)}" if 'reward' in task else f"{task.get('qol', 0)} QoL"
+                    task_rows.append([
+                        task['id'], task['name'], task['type'],
+                        f"{task['time']}h", req_str, reward_str
+                    ])
+            
+            # Task dropdown options
+            task_options = [(f"{t['id']} - {t['name']}", t['id']) for t in TASKS if t['id'] in state['task_ids']]
+            
+            # Spectators
+            spec_md = f"👥 {len(state['spectators'])} watching: {', '.join(state['spectators'])}" if state['spectators'] else "*No spectators*"
+            
+            # Turn indicator
+            if session.get('is_spectator'):
+                turn_msg = "👁️ You are spectating"
+            elif session.get('player_slot') == room['current_turn']:
+                turn_msg = "✅ **YOUR TURN!** Take an action below."
+            else:
+                turn_msg = "⏳ Waiting for partner's turn..."
+            
+            return (status_md, p1_data, p2_data, task_rows, spec_md, turn_msg)
+        
+        def execute_rest_handler(session, rest_type):
+            if not session.get('room_id') or session.get('is_spectator'):
+                return "❌ Not in game as player", session
+            
+            state = db.get_room_state(session['room_id'])
+            if not state:
+                return "❌ Room not found", session
+            
+            room = state['room']
+            if room['current_turn'] != session['player_slot']:
+                return "❌ Not your turn!", session
+            
+            player = state['players'][session['player_slot']]
+            success, msg, updates = execute_rest(player, rest_type)
+            
+            if success:
+                db.update_player(session['room_id'], session['player_slot'], updates)
+                return f"✅ {msg}", session
+            
+            return f"❌ {msg}", session
+        
+        def execute_solo_task_handler(session, task_id):
+            if not session.get('room_id') or session.get('is_spectator'):
+                return "❌ Not in game as player", session
+            
+            if not task_id:
+                return "❌ Select a task first", session
+            
+            state = db.get_room_state(session['room_id'])
+            if not state:
+                return "❌ Room not found", session
+            
+            room = state['room']
+            if room['current_turn'] != session['player_slot']:
+                return "❌ Not your turn!", session
+            
+            player = state['players'][session['player_slot']]
+            task = next((t for t in TASKS if t['id'] == task_id), None)
+            
+            if not task:
+                return "❌ Task not found", session
+            
+            success, msg, updates = execute_solo_task(player, task)
+            
+            if success:
+                # Add task to completed list
+                completed = json.loads(player.get('completed_tasks', '[]'))
+                completed.append(task_id)
+                updates['completed_tasks'] = json.dumps(completed)
+                
+                db.update_player(session['room_id'], session['player_slot'], updates)
+                return f"✅ {msg}", session
+            
+            return f"❌ {msg}", session
+        
+        def end_turn_handler(session):
+            if not session.get('room_id') or session.get('is_spectator'):
+                return "❌ Not in game as player", session
+            
+            state = db.get_room_state(session['room_id'])
+            if not state:
+                return "❌ Room not found", session
+            
+            room = state['room']
+            if room['current_turn'] != session['player_slot']:
+                return "❌ Not your turn!", session
+            
+            db.end_turn(session['room_id'], session['player_slot'])
+            return "✅ Turn ended. Waiting for partner...", session
+        
+        def load_rankings():
+            rankings = db.get_rankings(20)
+            rows = []
+            for i, r in enumerate(rankings, 1):
+                rows.append([
+                    i,
+                    r['player_name'],
+                    f"{r['avg_qol']:.1f}",
+                    r['total_games'],
+                    r['total_wins'],
+                    f"{r['win_rate']:.1f}%"
+                ])
+            return rows
+        
+        # Wire up events
+        create_btn.click(
+            create_room_handler,
+            inputs=[your_name_input, character_select],
+            outputs=[session_state, join_result]
+        )
+        
+        join_btn.click(
+            join_room_handler,
+            inputs=[room_id_input, your_name_input, character_select],
+            outputs=[session_state, join_result]
+        )
+        
+        refresh_btn.click(
+            refresh_game_state,
+            inputs=[session_state],
+            outputs=[status_display, p1_display, p2_display, tasks_display, 
+                    spectators_display, your_turn_msg]
+        )
+        
+        quick_nap_btn.click(
+            lambda s: execute_rest_handler(s, "quick_nap"),
+            inputs=[session_state],
+            outputs=[action_result, session_state]
+        ).then(
+            refresh_game_state,
+            inputs=[session_state],
+            outputs=[status_display, p1_display, p2_display, tasks_display,
+                    spectators_display, your_turn_msg]
+        )
+        
+        full_sleep_btn.click(
+            lambda s: execute_rest_handler(s, "full_sleep"),
+            inputs=[session_state],
+            outputs=[action_result, session_state]
+        ).then(
+            refresh_game_state,
+            inputs=[session_state],
+            outputs=[status_display, p1_display, p2_display, tasks_display,
+                    spectators_display, your_turn_msg]
+        )
+        
+        deep_rest_btn.click(
+            lambda s: execute_rest_handler(s, "deep_rest"),
+            inputs=[session_state],
+            outputs=[action_result, session_state]
+        ).then(
+            refresh_game_state,
+            inputs=[session_state],
+            outputs=[status_display, p1_display, p2_display, tasks_display,
+                    spectators_display, your_turn_msg]
+        )
+        
+        solo_task_btn.click(
+            execute_solo_task_handler,
+            inputs=[session_state, task_select],
+            outputs=[action_result, session_state]
+        ).then(
+            refresh_game_state,
+            inputs=[session_state],
+            outputs=[status_display, p1_display, p2_display, tasks_display,
+                    spectators_display, your_turn_msg]
+        )
+        
+        end_turn_btn.click(
+            end_turn_handler,
+            inputs=[session_state],
+            outputs=[action_result, session_state]
+        ).then(
+            refresh_game_state,
+            inputs=[session_state],
+            outputs=[status_display, p1_display, p2_display, tasks_display,
+                    spectators_display, your_turn_msg]
+        )
+        
+        refresh_rankings_btn.click(
+            load_rankings,
+            outputs=[rankings_table]
+        )
+        
+        # Auto-refresh on tab switch
+        app.load(load_rankings, outputs=[rankings_table])
+    
+    return app
+
+# ===== MAIN =====
+if __name__ == "__main__":
+    app = create_ui()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )