Update app.py

app.py

@@ -1,3 +1,4 @@
+# ===== app.py - Single Gradio App with SQLite =====
 """
 Life Frontier: Partner's Concerto
 Single-app turn-based game with SQLite state management
@@ -166,12 +167,16 @@ class GameDatabase:
     
     def create_room(self, room_id: str, total_rounds: int = 8) -> bool:
         with self.lock, self.get_connection() as conn:
+            # Cleanup old rooms before creating new one
+            self.cleanup_old_rooms()
+            
             try:
                 conn.execute("""
                     INSERT INTO rooms (room_id, total_rounds, created_at, status)
                     VALUES (?, ?, ?, 'waiting')
                 """, (room_id, total_rounds, datetime.now().isoformat()))
                 conn.commit()
+                print(f"✨ Created room {room_id}")
                 return True
             except sqlite3.IntegrityError:
                 return False
@@ -218,13 +223,15 @@ class GameDatabase:
                     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)
+                conn.commit()
+                return True, slot, f"✅ Joined as Player {slot + 1}! Game starting..."
             
-            return True, slot, f"Joined as Player {slot + 1}"
+            conn.commit()
+            return True, slot, f"Joined as Player {slot + 1}. Waiting for Player 2..."
     
     def _start_game(self, room_id: str, conn):
         """Internal: Start game when 2 players joined"""
@@ -239,7 +246,44 @@ class GameDatabase:
             UPDATE rooms SET available_tasks = ? WHERE room_id = ?
         """, (json.dumps(task_ids), room_id))
         
-        conn.commit()
+        print(f"🎮 Game started in room {room_id}!")
+    
+    def cleanup_old_rooms(self):
+        """Remove empty or stale rooms (no activity for 1 day)"""
+        with self.lock, self.get_connection() as conn:
+            cutoff_time = datetime.now().timestamp() - 86400  # 24 hours ago
+            
+            # Find stale rooms
+            stale_rooms = conn.execute("""
+                SELECT room_id FROM rooms 
+                WHERE status = 'waiting' 
+                AND strftime('%s', created_at) < ?
+            """, (cutoff_time,)).fetchall()
+            
+            # Also find empty rooms (no players after 1 hour)
+            empty_cutoff = datetime.now().timestamp() - 3600  # 1 hour ago
+            empty_rooms = conn.execute("""
+                SELECT r.room_id FROM rooms r
+                LEFT JOIN players p ON r.room_id = p.room_id
+                WHERE r.status = 'waiting'
+                AND p.room_id IS NULL
+                AND strftime('%s', r.created_at) < ?
+            """, (empty_cutoff,)).fetchall()
+            
+            rooms_to_delete = set(
+                [r['room_id'] for r in stale_rooms] + 
+                [r['room_id'] for r in empty_rooms]
+            )
+            
+            for room_id in rooms_to_delete:
+                # Delete associated data
+                conn.execute("DELETE FROM players WHERE room_id = ?", (room_id,))
+                conn.execute("DELETE FROM spectators WHERE room_id = ?", (room_id,))
+                conn.execute("DELETE FROM rooms WHERE room_id = ?", (room_id,))
+                print(f"🧹 Cleaned up stale room: {room_id}")
+            
+            conn.commit()
+            return len(rooms_to_delete)
     
     def get_room_state(self, room_id: str) -> Optional[Dict]:
         """Get complete room state including players"""
@@ -452,6 +496,24 @@ db = GameDatabase()
 def roll_dice() -> int:
     return random.randint(1, 6)
 
+def can_afford_task(player: Dict, task: Dict, is_solo: bool = True) -> Tuple[bool, str]:
+    """Check if player can afford task"""
+    req = task['solo'] if is_solo else task['coop']
+    
+    if player['time'] < task['time']:
+        return False, f"Not enough time (need {task['time']}h)"
+    
+    for res, amount in 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})"
+    
+    if 'cost' in task and player['money'] < task['cost']:
+        return False, f"Not enough money (need ${task['cost']})"
+    
+    return True, "OK"
+
 def execute_rest(player: Dict, rest_type: str) -> Tuple[bool, str, Dict]:
     """Execute rest action"""
     if rest_type == "quick_nap":
@@ -673,97 +735,139 @@ def create_ui():
         
         def refresh_game_state(session):
             if not session.get('room_id'):
-                return ("*No game joined*", {}, {}, [], "*No spectators*", "")
+                return ("*No game joined*", "", "", 0, 0, 0, 0, 0, 0,
+                       "", "", 0, 0, 0, 0, 0, 0, [], "", "*No spectators*", "")
             
             state = db.get_room_state(session['room_id'])
             if not state:
-                return ("*Room not found*", {}, {}, [], "*No spectators*", "")
+                return ("*Room not found*", "", "", 0, 0, 0, 0, 0, 0,
+                       "", "", 0, 0, 0, 0, 0, 0, [], "", "*No spectators*", "")
             
             room = state['room']
             players = state['players']
             
             # Status
             status_md = f"""
-            **Room:** {session['room_id']} | **Round:** {room['current_round']}/{room['total_rounds']}
+            **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']}"
+                winner_name = next((p['name'] for p in players if p['player_id'] == room['winner_id']), "Unknown")
+                status_md += f"\n\n🏆 **GAME OVER!** Winner: **{winner_name}**"
             
-            # Players
+            # Player 1 data
             p1_data = players[0] if len(players) > 0 else {}
+            p1_vals = (
+                p1_data.get('name', ''),
+                p1_data.get('character_id', ''),
+                p1_data.get('time', 0),
+                p1_data.get('money', 0),
+                p1_data.get('hp', 0),
+                p1_data.get('cp', 0),
+                p1_data.get('stress', 0),
+                p1_data.get('qol', 0)
+            )
+            
+            # Player 2 data
             p2_data = players[1] if len(players) > 1 else {}
+            p2_vals = (
+                p2_data.get('name', ''),
+                p2_data.get('character_id', ''),
+                p2_data.get('time', 0),
+                p2_data.get('money', 0),
+                p2_data.get('hp', 0),
+                p2_data.get('cp', 0),
+                p2_data.get('stress', 0),
+                p2_data.get('qol', 0)
+            )
             
-            # Tasks
+            # Tasks with better formatting
             task_rows = []
+            task_options = []
             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"
+                    solo_req = ', '.join([f"{k}:{v}" for k, v in task['solo'].items()])
+                    coop_req = ', '.join([f"{k}:{v}" for k, v in task['coop'].items()])
+                    
+                    if 'reward' in task and task['reward'] > 0:
+                        reward_str = f"${task['reward']}"
+                    elif 'qol' in task:
+                        reward_str = f"{task['qol']} QoL"
+                    else:
+                        reward_str = "Utility"
+                    
                     task_rows.append([
                         task['id'], task['name'], task['type'],
-                        f"{task['time']}h", req_str, reward_str
+                        f"{task['time']}h", solo_req, coop_req, 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']]
+                    task_options.append((f"{task['id']} - {task['name']}", task['id']))
             
             # 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"
+                turn_msg = "👁️ **You are spectating** - Refresh to see updates"
+            elif room['status'] == 'waiting':
+                turn_msg = "⏳ **Waiting for Player 2 to join...**"
+            elif room['status'] == 'finished':
+                turn_msg = "🏁 **Game Finished!** Check Rankings tab."
             elif session.get('player_slot') == room['current_turn']:
                 turn_msg = "✅ **YOUR TURN!** Take an action below."
             else:
-                turn_msg = "⏳ Waiting for partner's turn..."
+                turn_msg = "⏳ **Partner's turn...** Click Refresh to see updates."
             
-            return (status_md, p1_data, p2_data, task_rows, spec_md, turn_msg)
+            return (status_md, *p1_vals, *p2_vals, task_rows, task_options, 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
+                return "❌ Not in game as player"
             
             state = db.get_room_state(session['room_id'])
             if not state:
-                return "❌ Room not found", session
+                return "❌ Room not found"
             
             room = state['room']
+            if room['status'] != 'playing':
+                return "❌ Game not in progress"
+            
             if room['current_turn'] != session['player_slot']:
-                return "❌ Not your turn!", session
+                return "❌ Not your turn!"
             
             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}"
             
-            return f"❌ {msg}", session
+            return f"❌ {msg}"
         
         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
+                return "❌ Not in game as player"
             
             if not task_id:
-                return "❌ Select a task first", session
+                return "❌ Select a task first"
             
             state = db.get_room_state(session['room_id'])
             if not state:
-                return "❌ Room not found", session
+                return "❌ Room not found"
             
             room = state['room']
+            if room['status'] != 'playing':
+                return "❌ Game not in progress"
+            
             if room['current_turn'] != session['player_slot']:
-                return "❌ Not your turn!", session
+                return "❌ Not your turn!"
             
             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
+                return "❌ Task not found"
             
             success, msg, updates = execute_solo_task(player, task)
             
@@ -774,24 +878,27 @@ def create_ui():
                 updates['completed_tasks'] = json.dumps(completed)
                 
                 db.update_player(session['room_id'], session['player_slot'], updates)
-                return f"✅ {msg}", session
+                return f"✅ {msg}"
             
-            return f"❌ {msg}", session
+            return f"❌ {msg}"
         
         def end_turn_handler(session):
             if not session.get('room_id') or session.get('is_spectator'):
-                return "❌ Not in game as player", session
+                return "❌ Not in game as player"
             
             state = db.get_room_state(session['room_id'])
             if not state:
-                return "❌ Room not found", session
+                return "❌ Room not found"
             
             room = state['room']
+            if room['status'] != 'playing':
+                return "❌ Game not in progress"
+            
             if room['current_turn'] != session['player_slot']:
-                return "❌ Not your turn!", session
+                return "❌ Not your turn!"
             
             db.end_turn(session['room_id'], session['player_slot'])
-            return "✅ Turn ended. Waiting for partner...", session
+            return "✅ Turn ended. Waiting for partner..."
         
         def load_rankings():
             rankings = db.get_rankings(20)
@@ -823,63 +930,75 @@ def create_ui():
         refresh_btn.click(
             refresh_game_state,
             inputs=[session_state],
-            outputs=[status_display, p1_display, p2_display, tasks_display, 
-                    spectators_display, your_turn_msg]
+            outputs=[status_display, 
+                    p1_name, p1_character, p1_time, p1_money, p1_hp, p1_cp, p1_stress, p1_qol,
+                    p2_name, p2_character, p2_time, p2_money, p2_hp, p2_cp, p2_stress, p2_qol,
+                    tasks_display, task_select, 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]
+            outputs=[action_result]
         ).then(
             refresh_game_state,
             inputs=[session_state],
-            outputs=[status_display, p1_display, p2_display, tasks_display,
-                    spectators_display, your_turn_msg]
+            outputs=[status_display, 
+                    p1_name, p1_character, p1_time, p1_money, p1_hp, p1_cp, p1_stress, p1_qol,
+                    p2_name, p2_character, p2_time, p2_money, p2_hp, p2_cp, p2_stress, p2_qol,
+                    tasks_display, task_select, 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]
+            outputs=[action_result]
         ).then(
             refresh_game_state,
             inputs=[session_state],
-            outputs=[status_display, p1_display, p2_display, tasks_display,
-                    spectators_display, your_turn_msg]
+            outputs=[status_display, 
+                    p1_name, p1_character, p1_time, p1_money, p1_hp, p1_cp, p1_stress, p1_qol,
+                    p2_name, p2_character, p2_time, p2_money, p2_hp, p2_cp, p2_stress, p2_qol,
+                    tasks_display, task_select, 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]
+            outputs=[action_result]
         ).then(
             refresh_game_state,
             inputs=[session_state],
-            outputs=[status_display, p1_display, p2_display, tasks_display,
-                    spectators_display, your_turn_msg]
+            outputs=[status_display, 
+                    p1_name, p1_character, p1_time, p1_money, p1_hp, p1_cp, p1_stress, p1_qol,
+                    p2_name, p2_character, p2_time, p2_money, p2_hp, p2_cp, p2_stress, p2_qol,
+                    tasks_display, task_select, spectators_display, your_turn_msg]
         )
         
         solo_task_btn.click(
             execute_solo_task_handler,
             inputs=[session_state, task_select],
-            outputs=[action_result, session_state]
+            outputs=[action_result]
         ).then(
             refresh_game_state,
             inputs=[session_state],
-            outputs=[status_display, p1_display, p2_display, tasks_display,
-                    spectators_display, your_turn_msg]
+            outputs=[status_display, 
+                    p1_name, p1_character, p1_time, p1_money, p1_hp, p1_cp, p1_stress, p1_qol,
+                    p2_name, p2_character, p2_time, p2_money, p2_hp, p2_cp, p2_stress, p2_qol,
+                    tasks_display, task_select, spectators_display, your_turn_msg]
         )
         
         end_turn_btn.click(
             end_turn_handler,
             inputs=[session_state],
-            outputs=[action_result, session_state]
+            outputs=[action_result]
         ).then(
             refresh_game_state,
             inputs=[session_state],
-            outputs=[status_display, p1_display, p2_display, tasks_display,
-                    spectators_display, your_turn_msg]
+            outputs=[status_display, 
+                    p1_name, p1_character, p1_time, p1_money, p1_hp, p1_cp, p1_stress, p1_qol,
+                    p2_name, p2_character, p2_time, p2_money, p2_hp, p2_cp, p2_stress, p2_qol,
+                    tasks_display, task_select, spectators_display, your_turn_msg]
         )
         
         refresh_rankings_btn.click(
@@ -887,16 +1006,22 @@ def create_ui():
             outputs=[rankings_table]
         )
         
-        # Auto-refresh on tab switch
+        # Auto-load rankings on app start
         app.load(load_rankings, outputs=[rankings_table])
     
     return app
 
 # ===== MAIN =====
 if __name__ == "__main__":
+    print("🏠 Life Frontier: Partner's Concerto")
+    print("=" * 50)
+    print("Starting server...")
+    
     app = create_ui()
     app.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False
-    )
+        share=False,
+        show_error=True
+    )
+    print("\n✨ Server started! Open http://localhost:7860")