Update app.py

app.py

@@ -1,4 +1,4 @@
-# ===== app.py - Single Gradio App with SQLite =====
+"""# ===== app.py - Single Gradio App with SQLite =====
 """
 Life Frontier: Partner's Concerto
 Single-app turn-based game with SQLite state management
@@ -551,20 +551,12 @@ def execute_rest(player: Dict, rest_type: str) -> Tuple[bool, str, Dict]:
 
 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 affordability
+    can_afford, msg = can_afford_task(player, task, is_solo=True)
+    if not can_afford:
+        return False, msg, {}
     
-    # Check cost
-    if 'cost' in task and player['money'] < task['cost']:
-        return False, f"Not enough money (need ${task['cost']})", {}
+    solo_req = task['solo']
     
     # Execute
     updates = {
@@ -596,8 +588,12 @@ def execute_solo_task(player: Dict, task: Dict) -> Tuple[bool, str, Dict]:
                     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 == 'cp':
+                    updates['cp'] = min(updates.get('cp', player['cp']) + value, player['cp_max'])
                 elif eff_type == 'hp_max':
                     updates['hp_max'] = player['hp_max'] + value
+                elif eff_type == 'cp_max':
+                    updates['cp_max'] = player['cp_max'] + value
             elif effect == 'recover_all':
                 updates['hp'] = player['hp_max']
                 updates['cp'] = player['cp_max']
@@ -605,15 +601,77 @@ def execute_solo_task(player: Dict, task: Dict) -> Tuple[bool, str, Dict]:
     # 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
+        return True, f"⚠️ Task completed but ELIMINATED (stress reached {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"
+    # Build success message
+    msg_parts = [f"✓ {task['name']} completed!"]
+    if 'reward' in task and task['reward'] > 0:
+        msg_parts.append(f"+${task['reward']}")
+    if 'qol' in task and task['qol'] > 0:
+        msg_parts.append(f"+{task['qol']} QoL")
+    if 'effect' in task and 'stress:-' in task['effect']:
+        msg_parts.append(f"Stress reduced!")
+    
+    return True, " ".join(msg_parts), updates
+
+def initiate_negotiation(initiator: Dict, partner: Dict, task: Dict, 
+                        initiator_contrib: int) -> Tuple[bool, str, Dict]:
+    """Initiate cooperation negotiation"""
+    # Check initiator can afford their contribution
+    if initiator['cp'] < initiator_contrib:
+        return False, "Not enough CP to contribute", {}
+    
+    if initiator['time'] < task['time']:
+        return False, f"Not enough time (need {task['time']}h)", {}
+    
+    # Check task has coop requirements
+    if 'coop' not in task:
+        return False, "This task doesn't support cooperation", {}
+    
+    # Calculate target for partner
+    coop_req = task['coop']
+    total_needed = list(coop_req.values())[0]  # Get first requirement value
+    partner_target = total_needed - initiator_contrib
+    
+    if partner_target <= 0:
+        return False, "You're already contributing enough! Just do it solo.", {}
+    
+    # Save negotiation state
+    negotiation_data = {
+        'task_id': task['id'],
+        'initiator_contrib': initiator_contrib,
+        'partner_target': partner_target,
+        'total_needed': total_needed,
+        'pending': True
+    }
+    
+    return True, f"Negotiation started! Partner needs to contribute {partner_target} points.", negotiation_data
+
+def respond_negotiation(partner: Dict, negotiation: Dict, 
+                       cp_invest: int, hp_invest: int) -> Tuple[bool, str, int]:
+    """Partner responds to negotiation"""
+    if cp_invest < 1:
+        return False, "Must invest at least 1 CP", 0
+    
+    if partner['cp'] < cp_invest:
+        return False, f"Not enough CP (need {cp_invest})", 0
+    
+    if partner['hp'] < hp_invest:
+        return False, f"Not enough HP (need {hp_invest})", 0
     
-    return True, msg, updates
+    # Calculate result using formula
+    target = negotiation['partner_target']
+    investment = cp_invest + hp_invest
+    
+    # Simple formula: (target × investment) / investment = target
+    # But if investment < target, get proportional result
+    actual_contrib = min(target, investment)
+    
+    # Round up if close
+    if actual_contrib >= target * 0.9:
+        actual_contrib = target
+    
+    return True, f"Contributed {actual_contrib} points", actual_contrib
 
 # ===== GRADIO UI =====
 def create_ui():
@@ -656,7 +714,17 @@ def create_ui():
                 # Player 1 Panel
                 with gr.Column():
                     gr.Markdown("### Player 1")
-                    p1_display = gr.JSON(label="Status")
+                    p1_name = gr.Textbox(label="Name", interactive=False)
+                    p1_character = gr.Textbox(label="Character", interactive=False)
+                    with gr.Row():
+                        p1_time = gr.Number(label="⏰ Time", interactive=False)
+                        p1_money = gr.Number(label="💰 Money", interactive=False)
+                    with gr.Row():
+                        p1_hp = gr.Number(label="❤️ HP", interactive=False)
+                        p1_cp = gr.Number(label="🧠 CP", interactive=False)
+                    with gr.Row():
+                        p1_stress = gr.Number(label="😰 Stress", interactive=False)
+                        p1_qol = gr.Number(label="✨ QoL", interactive=False)
                 
                 # Center - Actions
                 with gr.Column():
@@ -665,32 +733,64 @@ def create_ui():
                     
                     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)")
+                        quick_nap_btn = gr.Button("🛌 Quick Nap (3h)", size="sm")
+                        full_sleep_btn = gr.Button("😴 Full Sleep (9h)", size="sm")
+                        deep_rest_btn = gr.Button("💤 Deep Rest (12h)", size="sm")
                     
                     gr.Markdown("**Available Tasks**")
                     tasks_display = gr.Dataframe(
-                        headers=["ID", "Name", "Type", "Time", "Requirements", "Reward"],
-                        label="Public Tasks"
+                        headers=["ID", "Name", "Type", "Time", "Req (Solo)", "Req (Coop)", "Reward"],
+                        label="Public Tasks",
+                        wrap=True
                     )
                     
-                    task_select = gr.Dropdown(label="Select Task")
-                    solo_task_btn = gr.Button("Execute Solo Task", variant="primary")
+                    task_select = gr.Dropdown(label="Select Task", choices=[])
                     
-                    end_turn_btn = gr.Button("⏭️ End Turn", variant="secondary")
+                    with gr.Row():
+                        solo_task_btn = gr.Button("▶️ Execute Solo", variant="primary")
+                        coop_task_btn = gr.Button("🤝 Propose Cooperation", variant="secondary")
+                    
+                    # Cooperation panel (initially hidden)
+                    with gr.Group(visible=False) as coop_panel:
+                        gr.Markdown("### 🤝 Cooperation Proposal")
+                        coop_contrib_slider = gr.Slider(1, 10, value=3, step=1, 
+                                                        label="Your CP Contribution")
+                        send_proposal_btn = gr.Button("📤 Send Proposal to Partner")
+                    
+                    # Negotiation response (for partner)
+                    with gr.Group(visible=False) as negotiation_panel:
+                        gr.Markdown("### 🤝 Partner's Cooperation Request")
+                        negotiation_info = gr.Markdown()
+                        with gr.Row():
+                            response_cp = gr.Slider(1, 10, value=1, step=1, label="Your CP Investment")
+                            response_hp = gr.Slider(0, 5, value=0, step=1, label="Your HP Investment")
+                        with gr.Row():
+                            accept_coop_btn = gr.Button("✅ Accept", variant="primary")
+                            reject_coop_btn = gr.Button("❌ Reject", variant="stop")
+                    
+                    end_turn_btn = gr.Button("⏭️ End Turn", variant="secondary", size="lg")
                     
                     action_result = gr.Markdown()
                 
                 # Player 2 Panel
                 with gr.Column():
                     gr.Markdown("### Player 2")
-                    p2_display = gr.JSON(label="Status")
+                    p2_name = gr.Textbox(label="Name", interactive=False)
+                    p2_character = gr.Textbox(label="Character", interactive=False)
+                    with gr.Row():
+                        p2_time = gr.Number(label="⏰ Time", interactive=False)
+                        p2_money = gr.Number(label="💰 Money", interactive=False)
+                    with gr.Row():
+                        p2_hp = gr.Number(label="❤️ HP", interactive=False)
+                        p2_cp = gr.Number(label="🧠 CP", interactive=False)
+                    with gr.Row():
+                        p2_stress = gr.Number(label="😰 Stress", interactive=False)
+                        p2_qol = gr.Number(label="✨ QoL", interactive=False)
             
             gr.Markdown("### Spectators")
             spectators_display = gr.Markdown("*No spectators*")
             
-            refresh_btn = gr.Button("🔄 Refresh Game State")
+            refresh_btn = gr.Button("🔄 Refresh Game State", variant="secondary")
         
         with gr.Tab("🏆 Rankings"):
             rankings_table = gr.Dataframe(
@@ -735,139 +835,97 @@ def create_ui():
         
         def refresh_game_state(session):
             if not session.get('room_id'):
-                return ("*No game joined*", "", "", 0, 0, 0, 0, 0, 0,
-                       "", "", 0, 0, 0, 0, 0, 0, [], "", "*No spectators*", "")
+                return ("*No game joined*", {}, {}, [], "*No spectators*", "")
             
             state = db.get_room_state(session['room_id'])
             if not state:
-                return ("*Room not found*", "", "", 0, 0, 0, 0, 0, 0,
-                       "", "", 0, 0, 0, 0, 0, 0, [], "", "*No spectators*", "")
+                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']}  
+            **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':
-                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}**"
+                status_md += f"\n\n🏆 **GAME OVER!** Winner: {room['winner_id']}"
             
-            # Player 1 data
+            # Players
             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 with better formatting
+            # Tasks
             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:
-                    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"
-                    
+                    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", solo_req, coop_req, reward_str
+                        f"{task['time']}h", req_str, reward_str
                     ])
-                    task_options.append((f"{task['id']} - {task['name']}", task['id']))
+            
+            # 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** - 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."
+                turn_msg = "👁️ You are spectating"
             elif session.get('player_slot') == room['current_turn']:
                 turn_msg = "✅ **YOUR TURN!** Take an action below."
             else:
-                turn_msg = "⏳ **Partner's turn...** Click Refresh to see updates."
+                turn_msg = "⏳ Waiting for partner's turn..."
             
-            return (status_md, *p1_vals, *p2_vals, task_rows, task_options, spec_md, turn_msg)
+            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"
+                return "❌ Not in game as player", session
             
             state = db.get_room_state(session['room_id'])
             if not state:
-                return "❌ Room not found"
+                return "❌ Room not found", session
             
             room = state['room']
-            if room['status'] != 'playing':
-                return "❌ Game not in progress"
-            
             if room['current_turn'] != session['player_slot']:
-                return "❌ Not your turn!"
+                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}"
+                return f"✅ {msg}", session
             
-            return f"❌ {msg}"
+            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"
+                return "❌ Not in game as player", session
             
             if not task_id:
-                return "❌ Select a task first"
+                return "❌ Select a task first", session
             
             state = db.get_room_state(session['room_id'])
             if not state:
-                return "❌ Room not found"
+                return "❌ Room not found", session
             
             room = state['room']
-            if room['status'] != 'playing':
-                return "❌ Game not in progress"
-            
             if room['current_turn'] != session['player_slot']:
-                return "❌ Not your turn!"
+                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"
+                return "❌ Task not found", session
             
             success, msg, updates = execute_solo_task(player, task)
             
@@ -878,27 +936,24 @@ def create_ui():
                 updates['completed_tasks'] = json.dumps(completed)
                 
                 db.update_player(session['room_id'], session['player_slot'], updates)
-                return f"✅ {msg}"
+                return f"✅ {msg}", session
             
-            return f"❌ {msg}"
+            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"
+                return "❌ Not in game as player", session
             
             state = db.get_room_state(session['room_id'])
             if not state:
-                return "❌ Room not found"
+                return "❌ Room not found", session
             
             room = state['room']
-            if room['status'] != 'playing':
-                return "❌ Game not in progress"
-            
             if room['current_turn'] != session['player_slot']:
-                return "❌ Not your turn!"
+                return "❌ Not your turn!", session
             
             db.end_turn(session['room_id'], session['player_slot'])
-            return "✅ Turn ended. Waiting for partner..."
+            return "✅ Turn ended. Waiting for partner...", session
         
         def load_rankings():
             rankings = db.get_rankings(20)
@@ -930,75 +985,63 @@ def create_ui():
         refresh_btn.click(
             refresh_game_state,
             inputs=[session_state],
-            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]
+            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]
+            outputs=[action_result, session_state]
         ).then(
             refresh_game_state,
             inputs=[session_state],
-            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]
+            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]
+            outputs=[action_result, session_state]
         ).then(
             refresh_game_state,
             inputs=[session_state],
-            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]
+            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]
+            outputs=[action_result, session_state]
         ).then(
             refresh_game_state,
             inputs=[session_state],
-            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]
+            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]
+            outputs=[action_result, session_state]
         ).then(
             refresh_game_state,
             inputs=[session_state],
-            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]
+            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]
+            outputs=[action_result, session_state]
         ).then(
             refresh_game_state,
             inputs=[session_state],
-            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]
+            outputs=[status_display, p1_display, p2_display, tasks_display,
+                    spectators_display, your_turn_msg]
         )
         
         refresh_rankings_btn.click(
@@ -1006,22 +1049,16 @@ def create_ui():
             outputs=[rankings_table]
         )
         
-        # Auto-load rankings on app start
+        # Auto-refresh on tab switch
         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,
-        show_error=True
+        share=False
     )
-    print("\n✨ Server started! Open http://localhost:7860")