Enhance game mechanics and UI: Update Gradio version, improve suspect card formatting, and add phone number handling for suspects

GEMINI.md

@@ -52,5 +52,5 @@ Since the project is a Gradio app:
 
 ### Key Directives
 - **Follow the Plan:** All development should align with the specifications in `PLan.md`.
-- **Gradio 5:** Use the latest Gradio features, particularly for custom UI components and state management.
+- **Gradio 6:** Use the latest Gradio features, particularly for custom UI components and state management.
 - **MCP Integration:** Tools should be designed to simulate real investigative data retrieval.

app.py

@@ -1,6 +1,7 @@
 import gradio as gr
 import os
 from game import game_engine
+from ui.components import format_tool_result_markdown, format_suspect_card
 
 # Load CSS
 with open("ui/styles.css", "r") as f:
@@ -11,29 +12,47 @@ def get_current_game(session_id):
         return None
     return game_engine.get_game(session_id)
 
-def format_suspect_card(suspect):
-    """Generates HTML for a suspect card."""
-    return f"""
-    <div class="suspect-card">
-        <h3>{suspect['name']}</h3>
-        <p><strong>Role:</strong> {suspect['role']}</p>
-        <p><strong>Bio:</strong> {suspect['bio']}</p>
-        <p>ID: {suspect['id']}</p>
-    </div>
-    """
-
-def start_new_game_ui(difficulty):
-    """Starts a new game and returns initial UI state."""
+def start_new_game_ui(scenario_name):
+    """Starts a new game based on scenario selection."""
+    
+    difficulty = "medium" # Default
+    if "Coffee Shop" in scenario_name:
+        difficulty = "easy"
+    elif "Gallery" in scenario_name:
+        difficulty = "hard"
+    
     session_id, game = game_engine.start_game(difficulty)
     
-    # Generate Suspect Cards HTML
-    cards = [format_suspect_card(s) for s in game.scenario["suspects"]]
-    # Pad if fewer than 4 (though scenarios have 4)
+    # Generate Suspect Cards HTML and Button Updates
+    suspects = game.scenario["suspects"]
+    cards = [format_suspect_card(s) for s in suspects]
+    
+    # Pad if fewer than 4
     while len(cards) < 4:
         cards.append("")
         
+    # Enable buttons for existing suspects
+    btn_updates = [gr.update(interactive=True, visible=True) for _ in suspects]
+    while len(btn_updates) < 4:
+        btn_updates.append(gr.update(interactive=False, visible=False))
+        
     # Initial Evidence Board
-    evidence_html = f"<h3>Case: {game.scenario['title']}</h3><p>Victim: {game.scenario['victim']['name']}</p><hr>"
+    victim_info = game.scenario['victim']
+    # Basic extraction of details if available, otherwise generic placeholders (based on plan/typical structure)
+    found_at = victim_info.get('found_at', victim_info.get('location', 'Unknown Location'))
+    cause_of_death = victim_info.get('cause_of_death', 'Unknown')
+    
+    evidence_md = f"""## 📁 Case: {game.scenario['title']}
+**Victim:** {victim_info['name']}
+**Time of Death:** {victim_info['time_of_death']}
+**Found At:** {found_at}
+**Cause of Death:** {cause_of_death}
+
+---
+
+### 🔎 Evidence Log
+*Evidence revealed during investigation will appear here.*
+"""
     
     # Initial Chat
     initial_chat = [
@@ -42,16 +61,26 @@ def start_new_game_ui(difficulty):
     
     return (
         session_id,
-        cards[0], cards[1], cards[2], cards[3], # Suspect cards
+        cards[0], cards[1], cards[2], cards[3], # Suspect HTML
+        btn_updates[0], btn_updates[1], btn_updates[2], btn_updates[3], # Suspect Buttons
         initial_chat, # Chatbot
-        evidence_html, # Evidence board
+        evidence_md, # Evidence board
         f"Round: {game.round}/5 | Points: {game.points}", # Stats
-        gr.update(choices=[(s['name'], s['id']) for s in game.scenario["suspects"]], value=None), # Suspect dropdown
+        None, # Reset selected suspect ID
         gr.update(interactive=True), # Question input
         gr.update(interactive=True), # Question btn
-        gr.update(interactive=True)  # Tool btn
+        gr.update(interactive=True), # Tool btn
+        "**Select a suspect to begin interrogation.**" # Status
     )
 
+def select_suspect_by_index(session_id, index):
+    game = get_current_game(session_id)
+    if not game or index >= len(game.scenario["suspects"]):
+        return None, "Error"
+    
+    suspect = game.scenario["suspects"][index]
+    return suspect['id'], f"**Interrogating:** {suspect['name']}"
+
 def submit_question(session_id, suspect_id, question, history):
     game = get_current_game(session_id)
     if not game:
@@ -65,25 +94,25 @@ def submit_question(session_id, suspect_id, question, history):
 
     response = game.question_suspect(suspect_id, question)
     
-    # Update chat
-    # Gradio 6 requires [{"role": "user", "content": "..."}, ...] format
+    # Look up suspect name for nicer chat
+    suspect_name = next((s["name"] for s in game.scenario["suspects"] if s["id"] == suspect_id), suspect_id)
     
-    history.append({"role": "user", "content": f"**Detective to {suspect_id}:** {question}"})
-    history.append({"role": "assistant", "content": f"**{suspect_id}:** {response}"})
+    history.append({"role": "user", "content": f"**Detective to {suspect_name}:** {question}"})
+    history.append({"role": "assistant", "content": f"**{suspect_name}:** {response}"})
     
     return history, "" # Clear input
 
-def use_tool_ui(session_id, tool_name, arg1, arg2, history):
+def use_tool_ui(session_id, tool_name, arg1, history, current_evidence_md):
     game = get_current_game(session_id)
     if not game:
-        return history, "No game", "Error"
+        return history, current_evidence_md, "Error"
         
     # Construct kwargs based on tool
     kwargs = {}
     if tool_name == "get_location":
-        kwargs = {"phone_number": arg1, "timestamp": arg2}
+        kwargs = {"phone_number": arg1}
     elif tool_name == "get_footage":
-        kwargs = {"location": arg1, "time_range": arg2}
+        kwargs = {"location": arg1}
     elif tool_name == "get_dna_test":
         kwargs = {"evidence_id": arg1}
     elif tool_name == "call_alibi":
@@ -91,23 +120,24 @@ def use_tool_ui(session_id, tool_name, arg1, arg2, history):
         
     result = game.use_tool(tool_name, **kwargs)
     
+    # Format the result
+    formatted_result = format_tool_result_markdown(tool_name, result)
+    
     # Update History
-    history.append({"role": "assistant", "content": f"🔧 **System:** Used {tool_name}\nResult: {result}"})
+    history.append({"role": "assistant", "content": f"🔧 **System:** Used {tool_name}\nInput: {arg1}\n\n{formatted_result}"})
     
     # Update Evidence Board
-    ev_html = f"<h3>Case: {game.scenario['title']}</h3><p>Victim: {game.scenario['victim']['name']}</p><hr><h4>Evidence Revealed:</h4><ul>"
-    for item in game.evidence_revealed:
-        ev_html += f"<li>{str(item)}</li>"
-    ev_html += "</ul>"
+    # We append the new formatted result to the markdown
+    new_evidence_md = current_evidence_md + f"\n\n---\n\n{formatted_result}"
     
     stats = f"Round: {game.round}/5 | Points: {game.points}"
     
-    return history, ev_html, stats
+    return history, new_evidence_md, stats
 
 def next_round_ui(session_id):
     game = get_current_game(session_id)
     if not game:
-        return "No game", "Error"
+        return "No game"
         
     not_over = game.advance_round()
     stats = f"Round: {game.round}/5 | Points: {game.points}"
@@ -126,28 +156,56 @@ with gr.Blocks(title="Murder.Ai") as demo:
     
     session_state = gr.State("")
     
+    # Top Controls
+    with gr.Row():
+        scenario_selector = gr.Dropdown(
+            choices=["The Silicon Valley Incident (Medium)", "The Coffee Shop Murder (Easy)", "The Gallery Heist (Hard)"],
+            value="The Silicon Valley Incident (Medium)",
+            label="Select Case Scenario"
+        )
+        start_btn = gr.Button("📂 LOAD CASE FILE", variant="primary")
+    
     with gr.Row():
         # Left: Suspect Cards
         with gr.Column(scale=1):
             gr.Markdown("## Suspects")
-            suspect_1 = gr.HTML(elem_classes="suspect-card")
-            suspect_2 = gr.HTML(elem_classes="suspect-card")
-            suspect_3 = gr.HTML(elem_classes="suspect-card")
-            suspect_4 = gr.HTML(elem_classes="suspect-card")
+            
+            # Suspect 1
+            with gr.Group():
+                s1_html = gr.HTML()
+                s1_btn = gr.Button("Interrogate", variant="secondary", visible=False)
+            
+            # Suspect 2
+            with gr.Group():
+                s2_html = gr.HTML()
+                s2_btn = gr.Button("Interrogate", variant="secondary", visible=False)
+                
+            # Suspect 3
+            with gr.Group():
+                s3_html = gr.HTML()
+                s3_btn = gr.Button("Interrogate", variant="secondary", visible=False)
+                
+            # Suspect 4
+            with gr.Group():
+                s4_html = gr.HTML()
+                s4_btn = gr.Button("Interrogate", variant="secondary", visible=False)
         
         # Center: Main Game Area
         with gr.Column(scale=2):
             game_stats = gr.Markdown("Round: 0/5 | Points: 10")
+            interrogation_status = gr.Markdown("**Select a suspect to begin interrogation.**")
             
             chatbot = gr.Chatbot(
                 label="Investigation Log",
                 height=500,
             )
             
+            # State variable to store selected suspect ID
+            selected_suspect_id = gr.State(value=None)
+            
             with gr.Row():
-                suspect_dropdown = gr.Dropdown(label="Select Suspect", choices=[])
-                question_input = gr.Textbox(label="Question", placeholder="Where were you?", interactive=False)
-                ask_btn = gr.Button("Ask", variant="secondary", interactive=False)
+                question_input = gr.Textbox(label="Question", placeholder="Where were you?", interactive=False, scale=4)
+                ask_btn = gr.Button("Ask", variant="secondary", interactive=False, scale=1)
             
             gr.Markdown("### Tools")
             with gr.Row():
@@ -156,8 +214,7 @@ with gr.Blocks(title="Murder.Ai") as demo:
                     choices=["get_location", "get_footage", "get_dna_test", "call_alibi"],
                     value="get_location"
                 )
-                arg1_input = gr.Textbox(label="Arg 1 (Phone/Loc/ID)")
-                arg2_input = gr.Textbox(label="Arg 2 (Time)")
+                arg1_input = gr.Textbox(label="Input (Phone / Location / ID)")
                 use_tool_btn = gr.Button("Use Tool", interactive=False)
 
             next_round_btn = gr.Button("▶️ Next Round / End Game")
@@ -165,43 +222,45 @@ with gr.Blocks(title="Murder.Ai") as demo:
         # Right: Evidence Board
         with gr.Column(scale=1):
             gr.Markdown("## Evidence Board")
-            evidence_board = gr.HTML(
-                elem_classes="evidence-board",
-                value="<p>No active case.</p>"
+            evidence_board = gr.Markdown(
+                value="Select a case to begin..."
             )
-    
-    # Start Controls
-    with gr.Row():
-        difficulty_selector = gr.Radio(["Easy", "Medium", "Hard"], label="Difficulty", value="Medium")
-        start_btn = gr.Button("🎲 GENERATE NEW CASE", variant="primary")
 
     # --- EVENTS ---
     
     start_btn.click(
         fn=start_new_game_ui,
-        inputs=[difficulty_selector],
+        inputs=[scenario_selector],
         outputs=[
             session_state,
-            suspect_1, suspect_2, suspect_3, suspect_4,
+            s1_html, s2_html, s3_html, s4_html,
+            s1_btn, s2_btn, s3_btn, s4_btn,
             chatbot,
             evidence_board,
             game_stats,
-            suspect_dropdown,
+            selected_suspect_id,
             question_input,
             ask_btn,
-            use_tool_btn
+            use_tool_btn,
+            interrogation_status
         ]
     )
     
+    # Suspect Selection Events
+    s1_btn.click(fn=lambda s: select_suspect_by_index(s, 0), inputs=[session_state], outputs=[selected_suspect_id, interrogation_status])
+    s2_btn.click(fn=lambda s: select_suspect_by_index(s, 1), inputs=[session_state], outputs=[selected_suspect_id, interrogation_status])
+    s3_btn.click(fn=lambda s: select_suspect_by_index(s, 2), inputs=[session_state], outputs=[selected_suspect_id, interrogation_status])
+    s4_btn.click(fn=lambda s: select_suspect_by_index(s, 3), inputs=[session_state], outputs=[selected_suspect_id, interrogation_status])
+    
     ask_btn.click(
         fn=submit_question,
-        inputs=[session_state, suspect_dropdown, question_input, chatbot],
+        inputs=[session_state, selected_suspect_id, question_input, chatbot],
         outputs=[chatbot, question_input]
     )
     
     use_tool_btn.click(
         fn=use_tool_ui,
-        inputs=[session_state, tool_dropdown, arg1_input, arg2_input, chatbot],
+        inputs=[session_state, tool_dropdown, arg1_input, chatbot, evidence_board],
         outputs=[chatbot, evidence_board, game_stats]
     )
     
@@ -212,7 +271,8 @@ with gr.Blocks(title="Murder.Ai") as demo:
     )
 
 demo.launch(
-    theme=gr.themes.Monochrome(),
-    css=custom_css,
-    allowed_paths=["."]
-)
+    server_name="0.0.0.0", 
+    server_port=7860,
+    allowed_paths=["."],
+    css=custom_css
+)

game/game_engine.py

@@ -40,6 +40,7 @@ class GameInstance:
                 "alibi_story": suspect["alibi_story"],
                 "bio": suspect["bio"],
                 "true_location": suspect["true_location"],
+                "phone_number": suspect.get("phone_number", "Unknown"), # Add phone number to context
                 
                 # Murderer specific
                 "method": self.scenario["title"], # Placeholder, scenario doesn't explicitly list 'method' field in plan, using title/weapon logic implied

mcp/tools.py

@@ -1,9 +1,22 @@
 import time
+import re
+
+def normalize_phone(phone):
+    """Strips non-digit characters from phone number for comparison."""
+    if not phone:
+        return ""
+    return re.sub(r"\D", "", phone)
 
 def find_suspect_by_phone(case_data, phone_number):
-    """Helper to find a suspect ID by their phone number."""
+    """Helper to find a suspect ID by their phone number (fuzzy match)."""
+    target_digits = normalize_phone(phone_number)
+    if not target_digits:
+        return None
+        
     for suspect in case_data["suspects"]:
-        if suspect["phone_number"] == phone_number:
+        suspect_digits = normalize_phone(suspect["phone_number"])
+        # Check if one ends with the other (to handle +1 vs no +1)
+        if target_digits.endswith(suspect_digits) or suspect_digits.endswith(target_digits):
             return suspect["id"]
     return None
 
@@ -14,40 +27,80 @@ def get_suspect_name(case_data, suspect_id):
             return suspect["name"]
     return "Unknown"
 
-def get_location(case_data, phone_number: str, timestamp: str) -> dict:
-    """Query the case database for location data."""
+def get_location(case_data, phone_number: str, timestamp: str = None) -> dict:
+    """
+    Query the case database for location data.
+    If timestamp is missing, searches for the time of death or returns all data.
+    """
     
     # Find which suspect has this phone number
     suspect_id = find_suspect_by_phone(case_data, phone_number)
     
     if not suspect_id:
-        return {"error": "Phone number not associated with any suspect."}
+        return {"error": f"Phone number {phone_number} not associated with any suspect."}
 
-    # Look up their location at this time
-    # Structure: case_data["evidence"]["location_data"][f"{suspect_id}_phone"][timestamp]
     phone_key = f"{suspect_id}_phone"
-    location_data = case_data.get("evidence", {}).get("location_data", {}).get(phone_key, {}).get(timestamp)
-    
-    if not location_data:
-        return {"error": f"No location data found for {phone_number} at {timestamp}."}
+    location_data_map = case_data.get("evidence", {}).get("location_data", {}).get(phone_key, {})
     
+    if not location_data_map:
+         return {"error": f"No location history found for {phone_number}."}
+
+    # If timestamp provided, look for exact match first
+    if timestamp:
+        location_data = location_data_map.get(timestamp)
+        if location_data:
+             return {
+                "timestamp": timestamp,
+                "coordinates": f"{location_data['lat']}, {location_data['lng']}",
+                "description": location_data['location'],
+                "accuracy": "Cell tower triangulation ±50m"
+            }
+        else:
+             return {"error": f"No data for {timestamp}. Available times: {list(location_data_map.keys())}"}
+    
+    # If no timestamp, return ALL data points found (or just the murder time one)
+    # Let's return the one closest to murder time (usually 8:47 PM in our main scenario)
+    # Or just return a list of all known locations.
+    
+    results = []
+    for time_key, loc in location_data_map.items():
+        results.append(f"{time_key}: {loc['location']}")
+        
     return {
-        "timestamp": timestamp,
-        "coordinates": f"{location_data['lat']}, {location_data['lng']}",
-        "description": location_data['location'],
-        "accuracy": "Cell tower triangulation ±50m"
+        "info": "Location History Found",
+        "history": results
     }
 
-def get_footage(case_data, location: str, time_range: str) -> dict:
+def get_footage(case_data, location: str, time_range: str = None) -> dict:
     """Query case database for camera footage."""
     
-    footage = case_data.get("evidence", {}).get("footage_data", {}).get(location, {}).get(time_range)
+    # Fuzzy match location keys
+    target_loc_key = None
+    footage_data = case_data.get("evidence", {}).get("footage_data", {})
+    
+    for loc_key in footage_data.keys():
+        if location.lower() in loc_key.lower() or loc_key.lower() in location.lower():
+            target_loc_key = loc_key
+            break
+            
+    if not target_loc_key:
+        return {"error": "No camera footage available at this location."}
+    
+    # If time_range not provided, return the first one found or all
+    loc_footage = footage_data[target_loc_key]
     
-    if not footage:
-        return {"error": "No camera footage available at this location/time."}
+    if time_range:
+        footage = loc_footage.get(time_range)
+        if not footage:
+             return {"error": f"No footage for time {time_range}. Available: {list(loc_footage.keys())}"}
+    else:
+        # Return the first available clip info
+        first_key = list(loc_footage.keys())[0]
+        footage = loc_footage[first_key]
+        time_range = first_key # Update for return
     
     return {
-        "location": location,
+        "location": target_loc_key,
         "time_range": time_range,
         "visible_people": footage["visible_people"],
         "quality": footage["quality"],
@@ -62,9 +115,6 @@ def get_dna_test(case_data, evidence_id: str) -> dict:
     if not dna:
         return {"error": "Evidence not found or not testable."}
     
-    # Simulate processing time
-    # time.sleep(1) 
-    
     primary_match_name = get_suspect_name(case_data, dna.get("primary_match"))
     
     return {
@@ -77,15 +127,21 @@ def get_dna_test(case_data, evidence_id: str) -> dict:
 def call_alibi(case_data, phone_number: str) -> dict:
     """Call an alibi witness."""
     
-    # Find alibi in database
+    # Find alibi in database - Fuzzy Match
     alibi = None
+    target_digits = normalize_phone(phone_number)
+    
+    if not target_digits:
+         return {"error": "Invalid phone number."}
+
     for suspect_alibi in case_data.get("evidence", {}).get("alibis", {}).values():
-        if suspect_alibi.get("contact") == phone_number:
+        contact_digits = normalize_phone(suspect_alibi.get("contact"))
+        if contact_digits and (target_digits.endswith(contact_digits) or contact_digits.endswith(target_digits)):
             alibi = suspect_alibi
             break
     
     if not alibi:
-        return {"error": "Number not found."}
+        return {"error": "Number not found or no alibi associated."}
     
     # If alibi is truthful, confirm story
     if alibi["truth"].startswith("Telling truth"):

prompts/murderer.txt

@@ -10,6 +10,9 @@ CASE DETAILS:
 - Location: {location}
 - Motive: {motive}
 
+YOUR DETAILS:
+- Phone Number: {phone_number}
+
 YOUR COVER STORY:
 - You were "{alibi_story}"
 - You have no alibi witnesses (unless specified otherwise)

prompts/witness.txt

@@ -5,6 +5,9 @@ TRUTH: You are INNOCENT. You did not commit the crime.
 CASE DETAILS:
 - Victim: {victim_name}
 
+YOUR DETAILS:
+- Phone Number: {phone_number}
+
 YOUR ALIBI:
 - You were "{alibi_story}"
 - You were at {true_location}

ui/components.py

@@ -0,0 +1,60 @@
+def format_tool_result_markdown(tool_name, result):
+    """Formats tool output as Markdown for the chat interface and evidence board."""
+    if "error" in result:
+        return f"❌ **Error:** {result['error']}"
+
+    output = ""
+    if tool_name == "get_location":
+        output += "### 📍 Location Data\n"
+        if "history" in result:
+            output += "**Movement History:**\n"
+            for h in result['history']:
+                # Try to make history lines cleaner if they are just strings
+                output += f"- {h}\n"
+        elif "info" in result and result['info'] != "Location History Found": 
+             # Only show info if it's an error or specific status, skip generic "Found"
+            output += f"**Status:** {result['info']}\n\n"
+
+    elif tool_name == "get_footage":
+        output += f"### 📹 CCTV Analysis\n"
+        output += f"- **Location:** {result.get('location', 'Unknown')}\n"
+        output += f"- **Time:** {result.get('time_range', 'N/A')}\n"
+        output += f"- **Quality:** {result.get('quality', 'N/A')}\n"
+        if "visible_people" in result:
+            people = ", ".join(result['visible_people'])
+            output += f"- **Visible:** {people}\n"
+        if "key_details" in result:
+            output += f"- **Key Details:** {result['key_details']}\n"
+
+    elif tool_name == "get_dna_test":
+        output += "### 🧬 DNA Analysis\n"
+        output += f"**Sample ID:** {result.get('evidence_id', 'Unknown')}\n"
+        if "result" in result:
+            output += f"**Result:** {result['result']}\n"
+        if "match" in result: 
+            output += f"**Match:** {result['match']}\n"
+
+    elif tool_name == "call_alibi":
+        output += "### 📞 Alibi Check\n"
+        if "status" in result: 
+            output += f"**Status:** {result['status']}\n"
+        if "statement" in result: 
+            output += f"**Statement:** \"{result['statement']}\"\n"
+    
+    else:
+        # Fallback for unknown tools or simple strings
+        output = str(result)
+    
+    return output
+
+def format_suspect_card(suspect):
+    """Generates HTML for a suspect card."""
+    return f"""
+    <div class="suspect-card">
+        <h3>{suspect['name']}</h3>
+        <p><strong>Role:</strong> {suspect['role']}</p>
+        <p><strong>Bio:</strong> {suspect['bio']}</p>
+        <p><strong>Phone:</strong> {suspect.get('phone_number', 'N/A')}</p>
+        <div style="margin-top: 5px; font-size: 0.8em; color: #666;">ID: {suspect['id']}</div>
+    </div>
+    """

ui/styles.css

@@ -4,25 +4,35 @@
     border-radius: 10px;
     border: 2px solid #d0d0d0;
     min-height: 300px;
+    color: #333 !important;
+}
+
+.evidence-board p, 
+.evidence-board h3, 
+.evidence-board h4, 
+.evidence-board li,
+.evidence-board ul {
+    color: #333 !important;
 }
 
 .suspect-card {
     background: linear-gradient(135deg, #2b32b2 0%, #1488cc 100%);
     border-radius: 15px;
     padding: 15px;
-    color: white;
+    color: white !important;
     margin-bottom: 10px;
     box-shadow: 0 4px 6px rgba(0,0,0,0.1);
 }
 
 .suspect-card h3 {
     margin-top: 0;
-    color: #fff;
+    color: #fff !important;
 }
 
 .suspect-card p {
     font-size: 0.9em;
     opacity: 0.9;
+    color: #eee !important;
 }
 
 .chat-message {