add new ver

app.py

@@ -13,18 +13,68 @@ import numpy as np
 if not hasattr(np, "bool"):  # pandas<2 compatibility on numpy>=2
     np.bool = bool  # type: ignore[attr-defined]
 
+EXAMPLE_PROMPT = "## Input-Output Example. When you submit an answer, the following lines will display the last input and the corresponding correct answer."
+LAST_PROMPT = "## The input and the correct output of the last question."
 import pandas as pd
 from PIL import Image, ImageDraw
+import plotly.graph_objects as go
+def _create_plotly_map(marker_lat: Optional[float] = None, marker_lon: Optional[float] = None):
+    """Create a Plotly map figure (OpenStreetMap) with optional visible marker.
+    Also adds a dense transparent grid of points so plotly_click 能在任意位置触发。
+    """
+    # Dense transparent grid points to capture clicks anywhere on the map
+    grid_lats: List[float] = []
+    grid_lons: List[float] = []
+    # 1° 网格，尽量保证任意点击都能命中到一个数据点
+    for lat in range(-90, 91, 1):
+        for lon in range(-180, 181, 1):
+            grid_lats.append(float(lat))
+            grid_lons.append(float(lon))
+
+    fig = go.Figure()
+    fig.add_trace(
+        go.Scattermap(
+            lat=grid_lats,
+            lon=grid_lons,
+            mode="markers",
+            marker=go.scattermap.Marker(size=40, color="#000"),
+            opacity=0.01,  # 透明但可点中
+            hoverinfo="skip",
+            name="grid",
+        )
+    )
+
+    if marker_lat is not None and marker_lon is not None:
+        fig.add_trace(
+            go.Scattermap(
+                lat=[marker_lat],
+                lon=[marker_lon],
+                mode="markers",
+                marker=go.scattermap.Marker(size=16, color="red"),
+                hoverinfo="text",
+                text=["Your guess"],
+                name="marker",
+            )
+        )
 
+    fig.update_layout(
+        map=dict(style="open-street-map", center=dict(lat=20, lon=0), zoom=2),
+        margin=dict(l=0, r=0, t=0, b=0),
+        height=600,
+        clickmode="event+select",  # 明确开启点击事件
+        dragmode="pan",
+    )
+    return fig
 import gradio as gr
+ 
 
 
-BASE_DIR = Path(__file__).resolve().parent
+BASE_DIR = Path(__file__).resolve().parents[1]
 DATASET_PATH = BASE_DIR / "data" / "dataset.csv"
 AUDIO_BASE_DIR = BASE_DIR / "data" / "audios"
-ASSETS_DIR = BASE_DIR / "assets"
+ASSETS_DIR = Path(__file__).resolve().parent / "assets"
 MAP_IMAGE_PATH = ASSETS_DIR / "world_map.png"
-LOG_PATH = BASE_DIR / "player_runs.csv"
+LOG_PATH = Path(__file__).resolve().parent / "player_runs.csv"
 RECENT_COLUMNS = ["timestamp", "player_id", "question_id", "distance_km"]
 
 
@@ -91,6 +141,36 @@ def _load_samples() -> List[Sample]:
     return samples
 
 
+def _get_example_sample() -> Optional[Sample]:
+    """Get the example sample (aporee_45102_51242) for the first round."""
+    if not DATASET_PATH.exists():
+        return None
+    
+    df = pd.read_csv(DATASET_PATH)
+    example_row = df[df["key"] == "aporee_45102_51242"]
+    
+    if example_row.empty:
+        return None
+    
+    row = example_row.iloc[0]
+    audio_path = AUDIO_BASE_DIR / row["mp3name"]
+    
+    if not audio_path.exists():
+        return None
+    
+    return Sample(
+        question_id=str(row["key"]),
+        audio_path=audio_path,
+        longitude=float(row["longitude"]),
+        latitude=float(row["latitude"]),
+        city=str(row.get("city", "") or ""),
+        country=str(row.get("country", "") or ""),
+        continent=str(row.get("continent", "") or ""),
+        description=str(row.get("description", "") or ""),
+        title=str(row.get("title", "") or ""),
+    )
+
+
 SAMPLES: List[Sample] = _load_samples()
 BASE_MAP_IMAGE = Image.open(MAP_IMAGE_PATH).convert("RGB")
 MAP_WIDTH, MAP_HEIGHT = BASE_MAP_IMAGE.size
@@ -145,9 +225,21 @@ def _base_map_array() -> np.ndarray:
     return np.array(BASE_MAP_IMAGE)
 
 
+ 
+
+def _on_coords_change(lon_text: str, lat_text: str) -> None:
+    """Log coordinate changes to backend terminal for debugging."""
+    try:
+        lon = float(lon_text) if lon_text else None
+        lat = float(lat_text) if lat_text else None
+        print(f"[PLOT CLICK] lon={lon} lat={lat}")
+    except Exception as e:
+        print(f"[PLOT CLICK] parse error: {e} | lon_text={lon_text} lat_text={lat_text}")
+
+
 def _prepare_clip_info(sample: Sample, round_idx: int) -> str:
     intro_lines = [
-        f"**Round:** {round_idx}"
+        f"## Question ID: {sample.question_id}. Now it's your turn to play."   
     ]
     return "\n\n".join(intro_lines)
 
@@ -193,14 +285,53 @@ def _format_recent_rows(rows: List[Dict[str, object]]) -> List[List[object]]:
     return formatted
 
 
-def initialize_round() -> Tuple[Dict[str, object], Dict[str, Optional[float]], str, str, np.ndarray, str, List[List[object]], str, str]:
+def _format_previous_answer(sample: Optional[Sample], is_example: bool = False, distance_km: Optional[float] = None, guess_lat: Optional[float] = None, guess_lon: Optional[float] = None) -> str:
+    """Format the previous answer display with location info and OpenStreetMap link."""
+    if sample is None:
+        return ""
+    
+    lat = sample.latitude
+    lon = sample.longitude
+    city = sample.city or "Unknown city"
+    country = sample.country or "Unknown country"
+    continent = sample.continent or "Unknown continent"
+    
+    # Create OpenStreetMap link
+    osm_link = f"https://www.openstreetmap.org/?mlat={lat}&mlon={lon}&zoom=15"
+    
+    lines = [
+        f"**Location:** {city}, {country}, {continent}",
+        f"**Coordinates:** {lat:.6f}°, {lon:.6f}°",
+    ]
+    
+    # Add player's prediction for non-example cases
+    if not is_example and guess_lat is not None and guess_lon is not None:
+        lines.append(f"**Your Prediction:** {guess_lat:.6f}°, {guess_lon:.6f}°")
+    
+    # Add error distance for non-example cases
+    if not is_example and distance_km is not None:
+        lines.append(f"**Error distance:** {distance_km:.1f} km")
+    
+    lines.append(f"**OpenStreetMap:** [View on map]({osm_link})")
+    
+    # Add example explanation if it's the example sample
+    if is_example and sample.question_id == "aporee_45102_51242":
+        lines.append("")
+        lines.append("**Explanation:** I can clearly identify the rolling of polyurethane wheels on concrete, the sharp 'pop' of a skateboard's tail hitting the ground to initiate a trick. This firmly places the recording at a skatepark. The background ambiance is that of a bustling city, characterized by the constant, though somewhat distant, hum of traffic. Furthermore, there are several instances of spoken English. The speakers have a clear North American English accent. The combination points to a major city in the United States with a prominent skate culture. New York City is one of the most iconic locations for street skateboarding globally.")
+    
+    return "\n\n".join(lines)
+
+
+def initialize_round() -> Tuple[Dict[str, object], Dict[str, Optional[float]], str, str, str, str, List[List[object]], str, str, str, str, str]:
     queue = _random_queue()
     current_index = queue.pop()
 
     state = {
-        "queue": queue,
+        "queue": queue, 
         "current_index": current_index,
         "round": 1,
+        "previous_sample": None,  # No previous sample for first round
+        "is_example": True,  # First round shows example
     }
 
     current_sample = SAMPLES[current_index]
@@ -209,8 +340,14 @@ def initialize_round() -> Tuple[Dict[str, object], Dict[str, Optional[float]], s
     prompt_text = "Click once on the map to pick your guess. The marker will update to your last selection."
     guess_state = {"lat": None, "lon": None, "pixel": None}
     recent_runs = _format_recent_rows(_load_recent_runs())
+    
+    # For first round, show example sample
+    example_sample = _get_example_sample()
+    previous_audio = str(example_sample.audio_path) if example_sample else None
+    previous_answer = _format_previous_answer(example_sample, is_example=True) if example_sample else ""
+    previous_title = EXAMPLE_PROMPT if example_sample else ""
 
-    return state, guess_state, audio_value, clip_md, _base_map_array(), prompt_text, recent_runs, "", ""
+    return state, guess_state, audio_value, clip_md, _create_plotly_map(), prompt_text, recent_runs, "", "", previous_audio or "", previous_answer, previous_title
 
 
 def _next_sample(state: Dict[str, object]) -> Sample:
@@ -238,44 +375,79 @@ def handle_map_click(
     evt: gr.SelectData,
     current_guess_state: Optional[Dict[str, Optional[float]]],
 ) -> Tuple[np.ndarray, str, Dict[str, Optional[float]], str, str]:
+    """Handle Plotly map click event to get coordinates."""
     guess_state = _ensure_guess_state(current_guess_state)
+    
     if evt is None:
         return _base_map_array(), "Unable to read selection. Please try again.", guess_state, "", ""
 
-    index = getattr(evt, "index", None)
-    value = getattr(evt, "value", None)
-
-    x = y = None
-    if isinstance(index, (tuple, list)) and len(index) >= 2:
-        x, y = index[0], index[1]
-    elif isinstance(index, dict):
-        x = index.get("x")
-        y = index.get("y")
-
-    if (x is None or y is None) and isinstance(value, dict):
-        x = value.get("x", x)
-        y = value.get("y", y)
-    elif (x is None or y is None) and isinstance(value, (tuple, list)) and len(value) >= 2:
-        if x is None:
-            x = value[0]
-        if y is None:
-            y = value[1]
-
-    if x is None or y is None:
-        return _base_map_array(), "Unable to read selection. Please try again.", guess_state, "", ""
-
-    x = int(x)
-    y = int(y)
-
-    lat, lon = _pixel_to_latlon(x, y)
-    guess_state = {"lat": lat, "lon": lon, "pixel": (x, y)}
-    image_with_marker = _map_with_marker(x, y)
-    return image_with_marker, _latlon_to_text(lat, lon), guess_state, f"{lon:.6f}", f"{lat:.6f}"
+    # Extract coordinates from Plotly SelectData
+    # Plotly SelectData for mapbox may have different structure
+    try:
+        lat = None
+        lon = None
+        
+        # Try different ways to extract coordinates
+        if hasattr(evt, 'points') and evt.points:
+            # Check if points is a list
+            if isinstance(evt.points, list) and len(evt.points) > 0:
+                point = evt.points[0]
+                if isinstance(point, dict):
+                    lat = point.get('lat') or point.get('latitude')
+                    lon = point.get('lon') or point.get('longitude')
+        
+        # Try index attribute
+        if (lat is None or lon is None) and hasattr(evt, 'index'):
+            if isinstance(evt.index, dict):
+                lat = evt.index.get('lat') or evt.index.get('latitude')
+                lon = evt.index.get('lon') or evt.index.get('longitude')
+        
+        # Try value attribute
+        if (lat is None or lon is None) and hasattr(evt, 'value'):
+            if isinstance(evt.value, dict):
+                lat = evt.value.get('lat') or evt.value.get('latitude')
+                lon = evt.value.get('lon') or evt.value.get('longitude')
+                # Also check nested points
+                if (lat is None or lon is None) and 'points' in evt.value:
+                    points = evt.value['points']
+                    if isinstance(points, list) and len(points) > 0:
+                        point = points[0]
+                        if isinstance(point, dict):
+                            lat = point.get('lat') or point.get('latitude')
+                            lon = point.get('lon') or point.get('longitude')
+        
+        # Debug: print the event structure
+        print(f"[MAP] SelectData event structure: {type(evt)}")
+        print(f"[MAP] Has points: {hasattr(evt, 'points')}")
+        print(f"[MAP] Has index: {hasattr(evt, 'index')}")
+        print(f"[MAP] Has value: {hasattr(evt, 'value')}")
+        if hasattr(evt, 'points'):
+            print(f"[MAP] Points: {evt.points}")
+        if hasattr(evt, 'index'):
+            print(f"[MAP] Index: {evt.index}")
+        if hasattr(evt, 'value'):
+            print(f"[MAP] Value: {evt.value}")
+        
+        if lat is None or lon is None:
+            return _base_map_array(), "Unable to read coordinates. Please try clicking on the map again.", guess_state, "", ""
+        
+        # Update guess state
+        guess_state = {"lat": float(lat), "lon": float(lon), "pixel": None}
+        # Create map with marker at clicked location
+        x = int((lon + 180.0) / 360.0 * MAP_WIDTH)
+        y = int((90.0 - lat) / 180.0 * MAP_HEIGHT)
+        image_with_marker = _map_with_marker(x, y)
+        return image_with_marker, _latlon_to_text(lat, lon), guess_state, f"{lon:.6f}", f"{lat:.6f}"
+    except Exception as e:
+        import traceback
+        print(f"[MAP] Error handling click: {e}")
+        print(f"[MAP] Traceback: {traceback.format_exc()}")
+        return _base_map_array(), f"Error: {str(e)}", guess_state, "", ""
 
 
 def submit_guess(
     player_id: str,
-    game_state: Dict[str, object],
+    game_state: Optional[Dict[str, object]],
     guess_state: Optional[Dict[str, Optional[float]]],
     longitude: str,
     latitude: str,
@@ -284,12 +456,19 @@ def submit_guess(
     Dict[str, Optional[float]],
     str,
     str,
-    np.ndarray,
+    str,
     str,
     List[List[object]],
     str,
     str,
+    str,
+    str,
+    str,
 ]:
+    if game_state is None:
+        # Re-initialize if state is lost
+        return initialize_round()
+    
     guess_state = _ensure_guess_state(guess_state)
     player_id = (player_id or "").strip()
     if not player_id:
@@ -297,16 +476,27 @@ def submit_guess(
         current_sample = SAMPLES[game_state["current_index"]]
         clip_md = _prepare_clip_info(current_sample, game_state.get("round", 1))
         prompt_text = message
+        previous_sample = game_state.get("previous_sample")
+        previous_audio = str(previous_sample.audio_path) if previous_sample else ""
+        previous_distance = game_state.get("previous_distance_km")
+        previous_guess_lat = game_state.get("previous_guess_lat")
+        previous_guess_lon = game_state.get("previous_guess_lon")
+        previous_answer = _format_previous_answer(previous_sample, distance_km=previous_distance, guess_lat=previous_guess_lat, guess_lon=previous_guess_lon) if previous_sample else ""
+        is_example = game_state.get("is_example", False)
+        previous_title = EXAMPLE_PROMPT if is_example else ""
         return (
             game_state,
             guess_state,
             str(current_sample.audio_path),
             clip_md,
-            _base_map_array(),
+            _create_plotly_map(),
             prompt_text,
             _format_recent_rows(_load_recent_runs()),
             longitude,
             latitude,
+            previous_audio,
+            previous_answer,
+            previous_title,
         )
 
     # Parse longitude and latitude from text inputs
@@ -319,16 +509,25 @@ def submit_guess(
             current_sample = SAMPLES[game_state["current_index"]]
             clip_md = _prepare_clip_info(current_sample, game_state.get("round", 1))
             prompt_text = message
+            previous_sample = game_state.get("previous_sample")
+            previous_audio = str(previous_sample.audio_path) if previous_sample else ""
+            previous_distance = game_state.get("previous_distance_km")
+            previous_answer = _format_previous_answer(previous_sample, distance_km=previous_distance) if previous_sample else ""
+            is_example = game_state.get("is_example", False)
+            previous_title = EXAMPLE_PROMPT if is_example else ""
             return (
                 game_state,
                 guess_state,
                 str(current_sample.audio_path),
                 clip_md,
-                _base_map_array(),
+                gr.update(),
                 prompt_text,
                 _format_recent_rows(_load_recent_runs()),
                 longitude,
                 latitude,
+                previous_audio,
+                previous_answer,
+                previous_title,
             )
         
         guess_lon = float(longitude)
@@ -340,16 +539,25 @@ def submit_guess(
             current_sample = SAMPLES[game_state["current_index"]]
             clip_md = _prepare_clip_info(current_sample, game_state.get("round", 1))
             prompt_text = message
+            previous_sample = game_state.get("previous_sample")
+            previous_audio = str(previous_sample.audio_path) if previous_sample else ""
+            previous_distance = game_state.get("previous_distance_km")
+            previous_answer = _format_previous_answer(previous_sample, distance_km=previous_distance) if previous_sample else ""
+            is_example = game_state.get("is_example", False)
+            previous_title = EXAMPLE_PROMPT if is_example else ""
             return (
                 game_state,
                 guess_state,
                 str(current_sample.audio_path),
                 clip_md,
-                _base_map_array(),
+                gr.update(),
                 prompt_text,
                 _format_recent_rows(_load_recent_runs()),
                 longitude,
                 latitude,
+                previous_audio,
+                previous_answer,
+                previous_title,
             )
         
         if not (-90 <= guess_lat <= 90):
@@ -357,32 +565,54 @@ def submit_guess(
             current_sample = SAMPLES[game_state["current_index"]]
             clip_md = _prepare_clip_info(current_sample, game_state.get("round", 1))
             prompt_text = message
+            previous_sample = game_state.get("previous_sample")
+            previous_audio = str(previous_sample.audio_path) if previous_sample else ""
+            previous_distance = game_state.get("previous_distance_km")
+            previous_guess_lat = game_state.get("previous_guess_lat")
+            previous_guess_lon = game_state.get("previous_guess_lon")
+            previous_answer = _format_previous_answer(previous_sample, distance_km=previous_distance, guess_lat=previous_guess_lat, guess_lon=previous_guess_lon) if previous_sample else ""
+            is_example = game_state.get("is_example", False)
+            previous_title = EXAMPLE_PROMPT if is_example else LAST_PROMPT
             return (
                 game_state,
                 guess_state,
                 str(current_sample.audio_path),
                 clip_md,
-                _base_map_array(),
+                gr.update(),
                 prompt_text,
                 _format_recent_rows(_load_recent_runs()),
                 longitude,
                 latitude,
+                previous_audio,
+                previous_answer,
+                previous_title,
             )
     except ValueError:
         message = "Invalid coordinates. Please enter valid numbers."
         current_sample = SAMPLES[game_state["current_index"]]
         clip_md = _prepare_clip_info(current_sample, game_state.get("round", 1))
         prompt_text = message
+        previous_sample = game_state.get("previous_sample")
+        previous_audio = str(previous_sample.audio_path) if previous_sample else ""
+        previous_distance = game_state.get("previous_distance_km")
+        previous_guess_lat = game_state.get("previous_guess_lat")
+        previous_guess_lon = game_state.get("previous_guess_lon")
+        previous_answer = _format_previous_answer(previous_sample, distance_km=previous_distance, guess_lat=previous_guess_lat, guess_lon=previous_guess_lon) if previous_sample else ""
+        is_example = game_state.get("is_example", False)
+        previous_title = EXAMPLE_PROMPT if is_example else LAST_PROMPT
         return (
             game_state,
             guess_state,
             str(current_sample.audio_path),
             clip_md,
-            _base_map_array(),
+            _create_plotly_map(),
             prompt_text,
             _format_recent_rows(_load_recent_runs()),
             longitude,
             latitude,
+            previous_audio,
+            previous_answer,
+            previous_title,
         )
 
     current_sample = SAMPLES[game_state["current_index"]]
@@ -414,6 +644,13 @@ def submit_guess(
     }
     _append_log(log_entry)
 
+    # Save current sample and distance as previous for next round
+    game_state["previous_sample"] = current_sample
+    game_state["previous_distance_km"] = distance_km
+    game_state["previous_guess_lat"] = guess_lat
+    game_state["previous_guess_lon"] = guess_lon
+    game_state["is_example"] = False  # After first round, it's no longer example
+    
     next_sample = _next_sample(game_state)
     audio_value = str(next_sample.audio_path)
     clip_md = _prepare_clip_info(next_sample, game_state["round"])
@@ -421,17 +658,28 @@ def submit_guess(
     new_guess_state = {"lat": None, "lon": None, "pixel": None}
     prompt_text = "Click once on the map to pick your guess. The marker will update to your last selection."
     recent_runs = _format_recent_rows(_load_recent_runs())
-
+    
+    # Format previous answer (current sample becomes previous for next round)
+    previous_audio = str(current_sample.audio_path)
+    previous_distance = game_state.get("previous_distance_km")
+    previous_guess_lat = game_state.get("previous_guess_lat")
+    previous_guess_lon = game_state.get("previous_guess_lon")
+    previous_answer = _format_previous_answer(current_sample, is_example=False, distance_km=previous_distance, guess_lat=previous_guess_lat, guess_lon=previous_guess_lon)
+    previous_title = LAST_PROMPT
+    
     return (
         game_state,
         new_guess_state,
         audio_value,
         clip_md,
-        _base_map_array(),
+        gr.update(),
         prompt_text,
         recent_runs,
         "",  # Reset longitude input
         "",  # Reset latitude input
+        previous_audio,
+        previous_answer,
+        previous_title,
     )
 
 
@@ -452,17 +700,27 @@ custom_css = """
     /* Apply size restrictions to regular (non-fullscreen) image */
     .gradio-image:not([class*="fullscreen"]) {
         max-width: 100% !important;
-        max-height: 600px !important;
+        max-height: none !important;
+        height: auto !important;
         margin: 0 auto !important;
-        display: flex !important;
-        justify-content: center !important;
+        display: block !important;
     }
     .gradio-image:not([class*="fullscreen"]) > div {
         max-width: 100% !important;
-        max-height: 600px !important;
+        max-height: none !important;
+        height: auto !important;
         margin: 0 auto !important;
-        display: flex !important;
-        justify-content: center !important;
+        display: block !important;
+    }
+    .gradio-image:not([class*="fullscreen"]) iframe,
+    .gradio-image:not([class*="fullscreen"]) div[id^="map-"] {
+        max-width: 100% !important;
+        max-height: none !important;
+        height: 800px !important;
+        min-height: 800px !important;
+        width: 100% !important;
+        margin: 0 auto !important;
+        display: block !important;
     }
     .gradio-image:not([class*="fullscreen"]) img {
         max-width: 100% !important;
@@ -472,6 +730,19 @@ custom_css = """
         object-fit: contain !important;
         margin: 0 auto !important;
     }
+    /* Ensure map plot has consistent height */
+    .gradio-plot {
+        min-height: 500px !important;
+        height: 500px !important;
+    }
+    /* Make sure the map column aligns properly */
+    .gradio-row > .gradio-column:first-child {
+        display: flex !important;
+        flex-direction: column !important;
+    }
+    .gradio-row > .gradio-column:first-child > * {
+        flex-shrink: 0 !important;
+    }
     /* Allow fullscreen modal to override size restrictions - higher specificity */
     /* Target common Gradio fullscreen containers */
     div[class*="modal"] .gradio-image,
@@ -546,18 +817,38 @@ with gr.Blocks(title="Audio Geo-Localization Game", theme=gr.themes.Soft(), css=
     guess_state = gr.State()
 
     
-    clip_info = gr.Markdown(label="Clip details", elem_classes=["clip-info"])
-        
+    # New row for previous question audio and answer with title
+    previous_title_display = gr.Markdown(value="", elem_classes=["clip-info"])
+    with gr.Row():
+        with gr.Column(scale=1):
+            previous_audio_player = gr.Audio(
+                label="Previous audio clip",
+                autoplay=False,
+                interactive=False,
+                streaming=False,
+                visible=True
+            )
+        with gr.Column(scale=1):
+            previous_answer_display = gr.Markdown(
+                label="Previous answer",
+                value="",
+                elem_classes=["clip-info"]
+            )
+            
+    # Add separator/divider between previous and current round
+    gr.Markdown("---")
+    
 
+    
+    clip_info = gr.Markdown(label="Clip details", elem_classes=["clip-info"])
+    
+    
     with gr.Row():
         with gr.Column(scale=2):
-            map_component = gr.Image(
-                value=_base_map_array(),
+            map_component = gr.Plot(
+                value=_create_plotly_map(),
                 label="World map (click to set your guess)",
-                interactive=True,
-                type="numpy",
-                image_mode="RGB",
-                elem_classes=["gradio-image"],
+                elem_classes=["gradio-image"]
             )
         
         with gr.Column(scale=1):
@@ -570,13 +861,15 @@ with gr.Blocks(title="Audio Geo-Localization Game", theme=gr.themes.Soft(), css=
             with gr.Row():
                 longitude_input = gr.Textbox(
                     label="Longitude",
-                    placeholder="Enter longitude (-180 to 180) or click map",
-                    elem_classes=["form-text"]
+                    placeholder="Enter longitude or click map",
+                    elem_classes=["form-text"],
+                    elem_id="lon_input"
                 )
                 latitude_input = gr.Textbox(
                     label="Latitude",
-                    placeholder="Enter latitude (-90 to 90) or click map",
-                    elem_classes=["form-text"]
+                    placeholder="Enter latitude or click map",
+                    elem_classes=["form-text"],
+                    elem_id="lat_input"
                 )
 
             submit_button = gr.Button("Submit Guess", variant="primary")
@@ -597,22 +890,261 @@ with gr.Blocks(title="Audio Geo-Localization Game", theme=gr.themes.Soft(), css=
     demo.load(
         initialize_round,
         inputs=None,
-        outputs=[game_state, guess_state, audio_player, clip_info, map_component, selection_text, recent_table, longitude_input, latitude_input],
+        outputs=[game_state, guess_state, audio_player, clip_info, map_component, selection_text, recent_table, longitude_input, latitude_input, previous_audio_player, previous_answer_display, previous_title_display]
     )
 
-    map_component.select(
-        handle_map_click,
-        inputs=[guess_state],
-        outputs=[map_component, selection_text, guess_state, longitude_input, latitude_input],
-        preprocess=False,
-    )
+    # 后端监听文本框变化，在终端打印坐标（便于你观察点击数据是否到达后端）
+    longitude_input.change(_on_coords_change, inputs=[longitude_input, latitude_input], outputs=[])
+    latitude_input.change(_on_coords_change, inputs=[longitude_input, latitude_input], outputs=[])
+
+    # Attach plotly_click to update the lon/lat textboxes (no Python roundtrip)
+    plotly_click_js = r"""
+() => {
+  console.log('[PLOTLY SETUP] Starting plotly click handler setup...');
+  
+  const updateInputs = (lat, lon) => {
+    console.log('[PLOTLY CLICK] Received coordinates:', {lat, lon});
+    
+    // Method 1: Try Gradio component API
+    if (window.gradio_app) {
+      try {
+        const components = window.gradio_app.__components || {};
+        Object.keys(components).forEach(key => {
+          const comp = components[key];
+          if (comp && comp.props && comp.props.elem_id) {
+            if (comp.props.elem_id === 'lon_input' && comp.component) {
+              comp.component.value = Number(lon).toFixed(6);
+              comp.component.dispatch('change');
+              console.log('[PLOTLY CLICK] Updated longitude via Gradio API');
+            }
+            if (comp.props.elem_id === 'lat_input' && comp.component) {
+              comp.component.value = Number(lat).toFixed(6);
+              comp.component.dispatch('change');
+              console.log('[PLOTLY CLICK] Updated latitude via Gradio API');
+            }
+          }
+        });
+      } catch (e) {
+        console.log('[PLOTLY CLICK] Gradio API method failed:', e);
+      }
+    }
+    
+    // Method 2: Find by label text, then find input nearby
+    const allLabels = Array.from(document.querySelectorAll('label'));
+    allLabels.forEach(label => {
+      const labelText = label.textContent.toLowerCase();
+      if (labelText.includes('longitude')) {
+        const container = label.closest('div, form, .gr-box');
+        if (container) {
+          const input = container.querySelector('input, textarea');
+          if (input) {
+            input.value = Number(lon).toFixed(6);
+            input.dispatchEvent(new Event('input', { bubbles: true }));
+            input.dispatchEvent(new Event('change', { bubbles: true }));
+            console.log('[PLOTLY CLICK] Updated longitude via label:', input.value);
+          }
+        }
+      }
+      if (labelText.includes('latitude')) {
+        const container = label.closest('div, form, .gr-box');
+        if (container) {
+          const input = container.querySelector('input, textarea');
+          if (input) {
+            input.value = Number(lat).toFixed(6);
+            input.dispatchEvent(new Event('input', { bubbles: true }));
+            input.dispatchEvent(new Event('change', { bubbles: true }));
+            console.log('[PLOTLY CLICK] Updated latitude via label:', input.value);
+          }
+        }
+      }
+    });
+    
+    // Method 3: Try finding by placeholder in all possible elements
+    const allElements = document.querySelectorAll('input, textarea, [contenteditable="true"]');
+    allElements.forEach(el => {
+      const ph = (el.placeholder || el.getAttribute('placeholder') || '').toLowerCase();
+      if (ph.includes('longitude') && !ph.includes('latitude')) {
+        if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
+          el.value = Number(lon).toFixed(6);
+          el.dispatchEvent(new Event('input', { bubbles: true }));
+          el.dispatchEvent(new Event('change', { bubbles: true }));
+          console.log('[PLOTLY CLICK] Updated longitude via placeholder:', el.value);
+        }
+      }
+      if (ph.includes('latitude') && !ph.includes('longitude')) {
+        if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
+          el.value = Number(lat).toFixed(6);
+          el.dispatchEvent(new Event('input', { bubbles: true }));
+          el.dispatchEvent(new Event('change', { bubbles: true }));
+          console.log('[PLOTLY CLICK] Updated latitude via placeholder:', el.value);
+        }
+      }
+    });
+    
+    console.log('[PLOTLY CLICK] Update attempts completed');
+  };
+  
+  const wirePlotly = () => {
+    const plots = document.querySelectorAll('.js-plotly-plot');
+    console.log('[PLOTLY SETUP] Found', plots.length, 'plotly plots');
+    
+    plots.forEach((plotDiv, idx) => {
+      if (plotDiv.dataset._wired === '1') {
+        console.log('[PLOTLY SETUP] Plot', idx, 'already wired');
+        return;
+      }
+      
+      console.log('[PLOTLY SETUP] Wiring plot', idx);
+      plotDiv.dataset._wired = '1';
+      
+      // Listen for plotly_click DOM event (Plotly fires this as a custom event)
+      plotDiv.addEventListener('plotly_click', (e) => {
+        console.log('[PLOTLY CLICK] Event received:', e);
+        console.log('[PLOTLY CLICK] e.points:', e.points);
+        
+        // Plotly click event data is directly on the event object
+        let points = e.points;
+        if (!points && e.detail) {
+          points = e.detail.points;
+        }
+        
+        if (points && points.length > 0) {
+          const pt = points[0];
+          console.log('[PLOTLY CLICK] Point data:', pt);
+          const lat = pt.lat;
+          const lon = pt.lon;
+          console.log('[PLOTLY CLICK] Extracted lat:', lat, 'lon:', lon);
+          if (lat !== undefined && lon !== undefined && !isNaN(lat) && !isNaN(lon)) {
+            updateInputs(lat, lon);
+          } else {
+            console.error('[PLOTLY CLICK] Invalid coordinates:', {lat, lon, point: pt});
+          }
+        } else {
+          console.error('[PLOTLY CLICK] No points found in event');
+        }
+      });
+      
+      // Fallback: Listen for raw click events and calculate coordinates from map config
+      plotDiv.addEventListener('click', (e) => {
+        console.log('[PLOTLY CLICK] Raw click event:', e);
+        
+        try {
+          if (!plotDiv._fullLayout || !plotDiv._fullLayout.map) {
+            console.error('[PLOTLY CLICK] map layout not available');
+            return;
+          }
+          
+          const mapConfig = plotDiv._fullLayout.map;
+          const center = mapConfig.center || {lat: 0, lon: 0};
+          const zoom = mapConfig.zoom || 2;
+          
+          console.log('[PLOTLY CLICK] Map config:', {center, zoom});
+          
+          // Get click position relative to plot div
+          const rect = plotDiv.getBoundingClientRect();
+          const width = rect.width;
+          const height = rect.height;
+          const x = e.clientX - rect.left;
+          const y = e.clientY - rect.top;
+          
+          console.log('[PLOTLY CLICK] Click position:', {x, y, width, height});
+          
+          // Convert pixel coordinates to lat/lon using Web Mercator projection
+          // Simplified calculation based on map center and zoom
+          const normalizedX = (x / width) - 0.5;  // -0.5 to 0.5
+          const normalizedY = 0.5 - (y / height);   // 0.5 to -0.5 (flipped Y)
+          
+          // Calculate pixel-to-degree conversion at current zoom
+          // At zoom level z, one tile = 256 pixels, world = 2^z tiles wide
+          const tilesAtZoom = Math.pow(2, zoom);
+          const pixelsPerTile = 256;
+          const worldWidthPixels = tilesAtZoom * pixelsPerTile;
+          const worldWidthDegrees = 360;
+          const degreesPerPixel = worldWidthDegrees / worldWidthPixels;
+          
+          // Longitude: linear mapping
+          const lon = center.lon + (normalizedX * width * degreesPerPixel);
+          
+          // Latitude: Web Mercator inverse
+          // Mercator Y at center: y_center = ln(tan(π/4 + center_lat/2))
+          // Click Y offset in pixels: dy = normalizedY * height
+          // Convert to Mercator units and then to latitude
+          const mercatorYCenter = Math.log(Math.tan(Math.PI / 4 + (center.lat * Math.PI / 180) / 2));
+          const dyMercator = normalizedY * height * degreesPerPixel / (180 / Math.PI);
+          const mercatorYClick = mercatorYCenter + dyMercator;
+          const latRad = 2 * Math.atan(Math.exp(mercatorYClick)) - Math.PI / 2;
+          const lat = latRad * 180 / Math.PI;
+          
+          console.log('[PLOTLY CLICK] Calculated coordinates - lat:', lat, 'lon:', lon);
+          
+          if (!isNaN(lat) && !isNaN(lon) && lat >= -90 && lat <= 90 && lon >= -180 && lon <= 180) {
+            updateInputs(lat, lon);
+          } else {
+            console.error('[PLOTLY CLICK] Invalid calculated coordinates:', {lat, lon});
+          }
+        } catch (err) {
+          console.error('[PLOTLY CLICK] Error in click handler:', err);
+          console.error('[PLOTLY CLICK] Error stack:', err.stack);
+        }
+      });
+      
+    });
+  };
+  
+  // Initial wire with retry logic
+  let retryCount = 0;
+  const maxRetries = 10;
+  const tryWire = () => {
+    const plots = document.querySelectorAll('.js-plotly-plot');
+    if (plots.length === 0 && retryCount < maxRetries) {
+      retryCount++;
+      console.log('[PLOTLY SETUP] No plots found, retry', retryCount, '/', maxRetries);
+      setTimeout(tryWire, 500);
+      return;
+    }
+    wirePlotly();
+    console.log('[PLOTLY SETUP] Initial wire complete, found', plots.length, 'plots');
+  };
+  
+  // Wait for Plotly library to load
+  if (window.Plotly) {
+    console.log('[PLOTLY SETUP] Plotly library found immediately');
+    setTimeout(tryWire, 1500);
+  } else {
+    console.warn('[PLOTLY SETUP] Plotly library not found, waiting...');
+    let plotlyWaitCount = 0;
+    const waitForPlotly = () => {
+      if (window.Plotly) {
+        console.log('[PLOTLY SETUP] Plotly library loaded after', plotlyWaitCount * 200, 'ms');
+        setTimeout(tryWire, 1000);
+      } else if (plotlyWaitCount < 20) {
+        plotlyWaitCount++;
+        setTimeout(waitForPlotly, 200);
+      } else {
+        console.error('[PLOTLY SETUP] Plotly library not found after 4 seconds, proceeding anyway');
+        setTimeout(tryWire, 1000);
+      }
+    };
+    waitForPlotly();
+  }
+  
+  // Watch for new plots
+  const obs = new MutationObserver(() => {
+    setTimeout(wirePlotly, 500);
+  });
+  obs.observe(document.body, { childList: true, subtree: true });
+}
+"""
+
+    demo.load(None, js=plotly_click_js)
 
     submit_button.click(
         submit_guess,
         inputs=[player_id, game_state, guess_state, longitude_input, latitude_input],
-        outputs=[game_state, guess_state, audio_player, clip_info, map_component, selection_text, recent_table, longitude_input, latitude_input],
+        outputs=[game_state, guess_state, audio_player, clip_info, map_component, selection_text, recent_table, longitude_input, latitude_input, previous_audio_player, previous_answer_display, previous_title_display],
     )
 
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=3828)
+    # Allow Gradio to serve audio files that live outside the CWD by whitelisting the project dir
+    demo.launch(server_name="0.0.0.0", server_port=38339, allowed_paths=[str(BASE_DIR)])

appPre.py

@@ -0,0 +1,618 @@
+from __future__ import annotations
+
+import csv
+import datetime as dt
+import math
+import random
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+
+if not hasattr(np, "bool"):  # pandas<2 compatibility on numpy>=2
+    np.bool = bool  # type: ignore[attr-defined]
+
+import pandas as pd
+from PIL import Image, ImageDraw
+
+import gradio as gr
+
+
+BASE_DIR = Path(__file__).resolve().parent
+DATASET_PATH = BASE_DIR / "data" / "dataset.csv"
+AUDIO_BASE_DIR = BASE_DIR / "data" / "audios"
+ASSETS_DIR = BASE_DIR / "assets"
+MAP_IMAGE_PATH = ASSETS_DIR / "world_map.png"
+LOG_PATH = BASE_DIR / "player_runs.csv"
+RECENT_COLUMNS = ["timestamp", "player_id", "question_id", "distance_km"]
+
+
+@dataclass
+class Sample:
+    question_id: str
+    audio_path: Path
+    longitude: float
+    latitude: float
+    city: str
+    country: str
+    continent: str
+    description: str
+    title: str
+
+
+def _load_samples() -> List[Sample]:
+    if not DATASET_PATH.exists():
+        raise FileNotFoundError(f"Dataset not found at {DATASET_PATH}")
+
+    df = pd.read_csv(DATASET_PATH)
+    start_idx = int(len(df) * 0.9)
+    test_df = df.iloc[start_idx:].reset_index(drop=True)
+
+    samples: List[Sample] = []
+    missing_audio = 0
+    missing_coords = 0
+
+    for row in test_df.itertuples():
+        audio_path = AUDIO_BASE_DIR / getattr(row, "mp3name")
+        longitude = getattr(row, "longitude")
+        latitude = getattr(row, "latitude")
+
+        if math.isnan(longitude) or math.isnan(latitude):
+            missing_coords += 1
+            continue
+
+        if not audio_path.exists():
+            missing_audio += 1
+            continue
+
+        samples.append(
+            Sample(
+                question_id=str(getattr(row, "key")),
+                audio_path=audio_path,
+                longitude=float(longitude),
+                latitude=float(latitude),
+                city=str(getattr(row, "city", "") or ""),
+                country=str(getattr(row, "country", "") or ""),
+                continent=str(getattr(row, "continent", "") or ""),
+                description=str(getattr(row, "description", "") or ""),
+                title=str(getattr(row, "title", "") or ""),
+            )
+        )
+
+    if not samples:
+        raise RuntimeError("No playable samples were found in the test split.")
+
+    if missing_audio:
+        print(f"[game_app] Skipped {missing_audio} samples because audio files are missing.")
+    if missing_coords:
+        print(f"[game_app] Skipped {missing_coords} samples because coordinates are missing.")
+
+    return samples
+
+
+SAMPLES: List[Sample] = _load_samples()
+BASE_MAP_IMAGE = Image.open(MAP_IMAGE_PATH).convert("RGB")
+MAP_WIDTH, MAP_HEIGHT = BASE_MAP_IMAGE.size
+
+
+def _random_queue() -> List[int]:
+    queue = list(range(len(SAMPLES)))
+    random.shuffle(queue)
+    return queue
+
+
+def _pixel_to_latlon(x: int, y: int) -> Tuple[float, float]:
+    lon = (x / (MAP_WIDTH - 1)) * 360.0 - 180.0
+    lat = 90.0 - (y / (MAP_HEIGHT - 1)) * 180.0
+    return round(lat, 6), round(lon, 6)
+
+
+def _latlon_to_text(lat: float, lon: float) -> str:
+    return f"Selected latitude {lat:.3f}°, longitude {lon:.3f}°"
+
+
+def _haversine(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    r = 6371.0
+    phi1, phi2 = math.radians(lat1), math.radians(lat2)
+    d_phi = math.radians(lat2 - lat1)
+    d_lambda = math.radians(lon2 - lon1)
+
+    a = math.sin(d_phi / 2.0) ** 2 + math.cos(phi1) * math.cos(phi2) * math.sin(d_lambda / 2.0) ** 2
+    c = 2.0 * math.atan2(math.sqrt(a), math.sqrt(1.0 - a))
+    return r * c
+
+
+def _map_with_marker(x: int, y: int) -> np.ndarray:
+    marker_radius = max(6, MAP_WIDTH // 150)
+    img = BASE_MAP_IMAGE.copy()
+    draw = ImageDraw.Draw(img)
+    draw.ellipse(
+        (
+            x - marker_radius,
+            y - marker_radius,
+            x + marker_radius,
+            y + marker_radius,
+        ),
+        fill=(225, 64, 64),
+        outline=(0, 0, 0),
+        width=2,
+    )
+    return np.array(img)
+
+
+def _base_map_array() -> np.ndarray:
+    return np.array(BASE_MAP_IMAGE)
+
+
+def _prepare_clip_info(sample: Sample, round_idx: int) -> str:
+    intro_lines = [
+        f"**Round:** {round_idx}"
+    ]
+    return "\n\n".join(intro_lines)
+
+
+def _append_log(entry: Dict[str, object]) -> None:
+    write_header = not LOG_PATH.exists()
+    with LOG_PATH.open("a", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=list(entry.keys()))
+        if write_header:
+            writer.writeheader()
+        writer.writerow(entry)
+
+
+def _load_recent_runs(limit: int = 5) -> List[Dict[str, object]]:
+    if not LOG_PATH.exists():
+        return []
+
+    rows = []
+    with LOG_PATH.open("r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            rows.append(row)
+    return rows[-limit:]
+
+
+def _format_recent_rows(rows: List[Dict[str, object]]) -> List[List[object]]:
+    formatted: List[List[object]] = []
+    for row in rows:
+        timestamp_str = row.get("timestamp", "")
+        if timestamp_str:
+            try:
+                # Parse ISO format timestamp and format as readable string
+                dt_obj = dt.datetime.fromisoformat(str(timestamp_str).replace('Z', '+00:00'))
+                formatted_timestamp = dt_obj.strftime("%Y-%m-%d %H:%M:%S")
+            except (ValueError, AttributeError):
+                formatted_timestamp = str(timestamp_str)
+        else:
+            formatted_timestamp = ""
+        
+        formatted_row = [formatted_timestamp]
+        formatted_row.extend([row.get(col, "") for col in RECENT_COLUMNS[1:]])
+        formatted.append(formatted_row)
+    return formatted
+
+
+def initialize_round() -> Tuple[Dict[str, object], Dict[str, Optional[float]], str, str, np.ndarray, str, List[List[object]], str, str]:
+    queue = _random_queue()
+    current_index = queue.pop()
+
+    state = {
+        "queue": queue,
+        "current_index": current_index,
+        "round": 1,
+    }
+
+    current_sample = SAMPLES[current_index]
+    audio_value = str(current_sample.audio_path)
+    clip_md = _prepare_clip_info(current_sample, state["round"])
+    prompt_text = "Click once on the map to pick your guess. The marker will update to your last selection."
+    guess_state = {"lat": None, "lon": None, "pixel": None}
+    recent_runs = _format_recent_rows(_load_recent_runs())
+
+    return state, guess_state, audio_value, clip_md, _base_map_array(), prompt_text, recent_runs, "", ""
+
+
+def _next_sample(state: Dict[str, object]) -> Sample:
+    queue: List[int] = state["queue"]
+    if not queue:
+        queue.extend(_random_queue())
+
+    next_index = queue.pop()
+    state["current_index"] = next_index
+    state["round"] = state.get("round", 1) + 1
+    return SAMPLES[next_index]
+
+
+def _ensure_guess_state(state: Optional[Dict[str, Optional[float]]]) -> Dict[str, Optional[float]]:
+    if not isinstance(state, dict):
+        return {"lat": None, "lon": None, "pixel": None}
+    return {
+        "lat": state.get("lat"),
+        "lon": state.get("lon"),
+        "pixel": state.get("pixel"),
+    }
+
+
+def handle_map_click(
+    evt: gr.SelectData,
+    current_guess_state: Optional[Dict[str, Optional[float]]],
+) -> Tuple[np.ndarray, str, Dict[str, Optional[float]], str, str]:
+    guess_state = _ensure_guess_state(current_guess_state)
+    if evt is None:
+        return _base_map_array(), "Unable to read selection. Please try again.", guess_state, "", ""
+
+    index = getattr(evt, "index", None)
+    value = getattr(evt, "value", None)
+
+    x = y = None
+    if isinstance(index, (tuple, list)) and len(index) >= 2:
+        x, y = index[0], index[1]
+    elif isinstance(index, dict):
+        x = index.get("x")
+        y = index.get("y")
+
+    if (x is None or y is None) and isinstance(value, dict):
+        x = value.get("x", x)
+        y = value.get("y", y)
+    elif (x is None or y is None) and isinstance(value, (tuple, list)) and len(value) >= 2:
+        if x is None:
+            x = value[0]
+        if y is None:
+            y = value[1]
+
+    if x is None or y is None:
+        return _base_map_array(), "Unable to read selection. Please try again.", guess_state, "", ""
+
+    x = int(x)
+    y = int(y)
+
+    lat, lon = _pixel_to_latlon(x, y)
+    guess_state = {"lat": lat, "lon": lon, "pixel": (x, y)}
+    image_with_marker = _map_with_marker(x, y)
+    return image_with_marker, _latlon_to_text(lat, lon), guess_state, f"{lon:.6f}", f"{lat:.6f}"
+
+
+def submit_guess(
+    player_id: str,
+    game_state: Dict[str, object],
+    guess_state: Optional[Dict[str, Optional[float]]],
+    longitude: str,
+    latitude: str,
+) -> Tuple[
+    Dict[str, object],
+    Dict[str, Optional[float]],
+    str,
+    str,
+    np.ndarray,
+    str,
+    List[List[object]],
+    str,
+    str,
+]:
+    guess_state = _ensure_guess_state(guess_state)
+    player_id = (player_id or "").strip()
+    if not player_id:
+        message = "Please enter your player ID before submitting."
+        current_sample = SAMPLES[game_state["current_index"]]
+        clip_md = _prepare_clip_info(current_sample, game_state.get("round", 1))
+        prompt_text = message
+        return (
+            game_state,
+            guess_state,
+            str(current_sample.audio_path),
+            clip_md,
+            _base_map_array(),
+            prompt_text,
+            _format_recent_rows(_load_recent_runs()),
+            longitude,
+            latitude,
+        )
+
+    # Parse longitude and latitude from text inputs
+    try:
+        longitude = longitude.strip() if longitude else ""
+        latitude = latitude.strip() if latitude else ""
+        
+        if not longitude or not latitude:
+            message = "Please enter both longitude and latitude, or click on the map to select a location."
+            current_sample = SAMPLES[game_state["current_index"]]
+            clip_md = _prepare_clip_info(current_sample, game_state.get("round", 1))
+            prompt_text = message
+            return (
+                game_state,
+                guess_state,
+                str(current_sample.audio_path),
+                clip_md,
+                _base_map_array(),
+                prompt_text,
+                _format_recent_rows(_load_recent_runs()),
+                longitude,
+                latitude,
+            )
+        
+        guess_lon = float(longitude)
+        guess_lat = float(latitude)
+        
+        # Validate ranges
+        if not (-180 <= guess_lon <= 180):
+            message = "Longitude must be between -180 and 180."
+            current_sample = SAMPLES[game_state["current_index"]]
+            clip_md = _prepare_clip_info(current_sample, game_state.get("round", 1))
+            prompt_text = message
+            return (
+                game_state,
+                guess_state,
+                str(current_sample.audio_path),
+                clip_md,
+                _base_map_array(),
+                prompt_text,
+                _format_recent_rows(_load_recent_runs()),
+                longitude,
+                latitude,
+            )
+        
+        if not (-90 <= guess_lat <= 90):
+            message = "Latitude must be between -90 and 90."
+            current_sample = SAMPLES[game_state["current_index"]]
+            clip_md = _prepare_clip_info(current_sample, game_state.get("round", 1))
+            prompt_text = message
+            return (
+                game_state,
+                guess_state,
+                str(current_sample.audio_path),
+                clip_md,
+                _base_map_array(),
+                prompt_text,
+                _format_recent_rows(_load_recent_runs()),
+                longitude,
+                latitude,
+            )
+    except ValueError:
+        message = "Invalid coordinates. Please enter valid numbers."
+        current_sample = SAMPLES[game_state["current_index"]]
+        clip_md = _prepare_clip_info(current_sample, game_state.get("round", 1))
+        prompt_text = message
+        return (
+            game_state,
+            guess_state,
+            str(current_sample.audio_path),
+            clip_md,
+            _base_map_array(),
+            prompt_text,
+            _format_recent_rows(_load_recent_runs()),
+            longitude,
+            latitude,
+        )
+
+    current_sample = SAMPLES[game_state["current_index"]]
+    true_lat = current_sample.latitude
+    true_lon = current_sample.longitude
+
+    distance_km = _haversine(true_lat, true_lon, guess_lat, guess_lon)
+    reveal_lines = [
+        f"Real location: {current_sample.city or 'Unknown city'}, {current_sample.country or 'Unknown country'} ({true_lat:.3f}°, {true_lon:.3f}°)",
+        f"Your guess: ({guess_lat:.3f}°, {guess_lon:.3f}°)",
+        f"Error distance: {distance_km:.1f} km",
+    ]
+
+    log_entry = {
+        "timestamp": dt.datetime.utcnow().isoformat(),
+        "player_id": player_id,
+        "question_id": current_sample.question_id,
+        "audio_path": str(current_sample.audio_path),
+        "guess_latitude": guess_lat,
+        "guess_longitude": guess_lon,
+        "true_latitude": true_lat,
+        "true_longitude": true_lon,
+        "distance_km": round(distance_km, 3),
+        "city": current_sample.city,
+        "country": current_sample.country,
+        "continent": current_sample.continent,
+        "title": current_sample.title,
+        "description": current_sample.description,
+    }
+    _append_log(log_entry)
+
+    next_sample = _next_sample(game_state)
+    audio_value = str(next_sample.audio_path)
+    clip_md = _prepare_clip_info(next_sample, game_state["round"])
+
+    new_guess_state = {"lat": None, "lon": None, "pixel": None}
+    prompt_text = "Click once on the map to pick your guess. The marker will update to your last selection."
+    recent_runs = _format_recent_rows(_load_recent_runs())
+
+    return (
+        game_state,
+        new_guess_state,
+        audio_value,
+        clip_md,
+        _base_map_array(),
+        prompt_text,
+        recent_runs,
+        "",  # Reset longitude input
+        "",  # Reset latitude input
+    )
+
+
+custom_css = """
+    h1 {
+        font-size: 2.5rem !important;
+        font-weight: 700 !important;
+        margin-bottom: 1rem !important;
+        text-align: center !important;
+    }
+    .intro-text {
+        font-size: 1.1rem !important;
+        line-height: 1.6 !important;
+        margin-bottom: 1.5rem !important;
+        color: #555 !important;
+        text-align: center !important;
+    }
+    /* Apply size restrictions to regular (non-fullscreen) image */
+    .gradio-image:not([class*="fullscreen"]) {
+        max-width: 100% !important;
+        max-height: 600px !important;
+        margin: 0 auto !important;
+        display: flex !important;
+        justify-content: center !important;
+    }
+    .gradio-image:not([class*="fullscreen"]) > div {
+        max-width: 100% !important;
+        max-height: 600px !important;
+        margin: 0 auto !important;
+        display: flex !important;
+        justify-content: center !important;
+    }
+    .gradio-image:not([class*="fullscreen"]) img {
+        max-width: 100% !important;
+        max-height: 600px !important;
+        width: auto !important;
+        height: auto !important;
+        object-fit: contain !important;
+        margin: 0 auto !important;
+    }
+    /* Allow fullscreen modal to override size restrictions - higher specificity */
+    /* Target common Gradio fullscreen containers */
+    div[class*="modal"] .gradio-image,
+    div[class*="modal"] .gradio-image > div,
+    div[class*="modal"] .gradio-image img,
+    div[class*="fullscreen"] .gradio-image,
+    div[class*="fullscreen"] .gradio-image > div,
+    div[class*="fullscreen"] .gradio-image img,
+    div[id*="lightbox"] .gradio-image,
+    div[id*="lightbox"] .gradio-image img,
+    .gradio-image[class*="fullscreen"],
+    .gradio-image[class*="fullscreen"] > div,
+    .gradio-image[class*="fullscreen"] img {
+        max-width: none !important;
+        max-height: none !important;
+        width: 100% !important;
+        height: 100% !important;
+    }
+    .selection-text {
+        font-size: 1.15rem !important;
+        text-align: left !important;
+        color: #666 !important;
+        margin: 0.5rem 0 !important;
+    }
+    .selection-text * {
+        font-size: 1.15rem !important;
+    }
+    .feedback-box {
+        font-size: 1.15rem !important;
+        line-height: 1.6 !important;
+    }
+    .feedback-box p,
+    .feedback-box div,
+    .feedback-box span {
+        font-size: 1.15rem !important;
+        line-height: 1.6 !important;
+    }
+    .clip-info {
+        font-size: 1.1rem !important;
+    }
+    .clip-info p,
+    .clip-info div,
+    .clip-info span {
+        font-size: 1.1rem !important;
+    }
+    .clip-info label {
+        font-size: 1.1rem !important;
+        font-weight: 600 !important;
+    }
+    label {
+        font-size: 1rem !important;
+        font-weight: 500 !important;
+    }
+    .form-text input {
+        font-size: 0.95rem !important;
+    }
+    /* Table label styling - only target the label, not table content */
+    .gradio-dataframe label,
+    [data-testid="dataframe"] label,
+    label[for*="recent"],
+    .form-group label {
+        font-size: 1.15rem !important;
+        font-weight: 600 !important;
+    }
+"""
+
+with gr.Blocks(title="Audio Geo-Localization Game", theme=gr.themes.Soft(), css=custom_css) as demo:
+    gr.Markdown("# Audio Geo-Localization Game")
+    gr.HTML('<p class="intro-text">Welcome to the Audio Geo-Localization Game. Listen to an ambient audio clip, then guess where it was recorded by clicking on the world map. Submit to see the true location and how close you came.</p>')
+
+    game_state = gr.State()
+    guess_state = gr.State()
+
+    
+    clip_info = gr.Markdown(label="Clip details", elem_classes=["clip-info"])
+        
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            map_component = gr.Image(
+                value=_base_map_array(),
+                label="World map (click to set your guess)",
+                interactive=True,
+                type="numpy",
+                image_mode="RGB",
+                elem_classes=["gradio-image"],
+            )
+        
+        with gr.Column(scale=1):
+            player_id = gr.Textbox(label="Player ID", placeholder="Enter an identifier so scores can be tracked", elem_classes=["form-text"])
+            
+            audio_player = gr.Audio(label="Mystery audio clip", autoplay=False, interactive=False, streaming=False)
+
+            selection_text = gr.Markdown("Click once on the map to pick your guess. The marker will update to your last selection.", elem_classes=["selection-text"])
+
+            with gr.Row():
+                longitude_input = gr.Textbox(
+                    label="Longitude",
+                    placeholder="Enter longitude (-180 to 180) or click map",
+                    elem_classes=["form-text"]
+                )
+                latitude_input = gr.Textbox(
+                    label="Latitude",
+                    placeholder="Enter latitude (-90 to 90) or click map",
+                    elem_classes=["form-text"]
+                )
+
+            submit_button = gr.Button("Submit Guess", variant="primary")
+    recent_table = gr.Dataframe(
+        headers=[
+            "timestamp",
+            "player_id",
+            "question_id",
+            "distance_km",
+        ],
+        datatype=["str", "str", "str", "number"],
+        value=[],
+        interactive=False,
+        label="Recent submissions (latest last)",
+        wrap=True,
+    )
+
+    demo.load(
+        initialize_round,
+        inputs=None,
+        outputs=[game_state, guess_state, audio_player, clip_info, map_component, selection_text, recent_table, longitude_input, latitude_input],
+    )
+
+    map_component.select(
+        handle_map_click,
+        inputs=[guess_state],
+        outputs=[map_component, selection_text, guess_state, longitude_input, latitude_input],
+        preprocess=False,
+    )
+
+    submit_button.click(
+        submit_guess,
+        inputs=[player_id, game_state, guess_state, longitude_input, latitude_input],
+        outputs=[game_state, guess_state, audio_player, clip_info, map_component, selection_text, recent_table, longitude_input, latitude_input],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=3828)

player_runs.csv

@@ -18,3 +18,9 @@ timestamp,player_id,question_id,audio_path,guess_latitude,guess_longitude,true_l
 2025-11-05T19:07:06.291597,hekki,aporee_42331_48275,/home/zhangrx/SoundingEarth/data/audios/190104152720nimmermeinefreundin20190105000218.mp3,39.893575,117.559826,47.269730795987,11.391281483893,7890.937,Innsbruck,Austria,Europe,"Innstraße 21, 6020 Innsbruck, Österreich - girls talk",girl playing with friendship
 2025-11-05T19:07:07.756012,hekki,aporee_33154_38104,/home/zhangrx/SoundingEarth/data/audios/1608060553summerrain.mp3,39.775741,117.203053,52.474707169672,13.423805683851,7414.23,Tempelhof Bezirk,Germany,Europe,"Schillerkiez, Berlin, Germany - summer rain",summer rain recorded from in between the old double windows
 2025-11-05T19:18:37.169326,hekki,aporee_9261_11137,/home/zhangrx/SoundingEarth/data/audios/04temporale.mp3,40.035529,116.564321,45.5534230384,8.95841985941,8085.955,Parabiago,Italy,Europe,"via Oidio, Parabiago, Temporale estivo",Un temporale estivo rinfresca un caldo pomeriggio di agosto
+2025-11-06T16:53:32.981561,232323,aporee_7387_9112,/home/zhangrx/SoundingEarth/data/audios/10071805.mp3,66.587537,105.261608,41.8814299789,-87.6853635907,7903.304,Chicago,United States,North America,Walgreens on World Listening Day - shopping and recording in Walgreens,"walking through Walgreens store, guitar toys display, refrigerator drones, moozak, shoppers, cashiers, World Listening Day, WLD"
+2025-11-06T16:54:02.290489,232323,aporee_12215_14310,/home/zhangrx/SoundingEarth/data/audios/primadellospettacolo.mp3,32.046695,171.327748,45.4709716191,9.19473588467,11209.031,Milano,Italy,Europe,Teatro Manzoni - prima dello spettacolo,crowded indoor teathre
+2025-11-06T16:59:03.170077,23333,aporee_14899_17370,/home/zhangrx/SoundingEarth/data/audios/conveyerbelt.mp3,57.581051,127.410046,50.430385130568,13.318594859,6588.151,Krasna Lipa,Czechia,Europe,"Málkov, Czech Republic - Nástup mine - Conveyer belt",The sound at the start of the coal's long (sometimes kilometers) conveyer belt journey to the grinding plant. Here the lumps are crushed to a uniform 6cm size appropriate for burning in power stations
+2025-11-06T17:05:00.255666,sdsad,aporee_8087_9860,/home/zhangrx/SoundingEarth/data/audios/Firemen.mp3,69.700179,51.64993,48.8537809597,2.34422922134,3472.493,Paris,France,Europe,"Quai des Grands Augustins, Paris - Firemen stuck in traffic","Firemen stuck in traffic, Pont St. Michel, Paris. After de car finaly passes you can hear a child singing the sirene melody."
+2025-11-06T17:15:59.301123,sfsd,aporee_10756_12758,/home/zhangrx/SoundingEarth/data/audios/WolfburgParkhotelAufzug02.mp3,39.367256,116.267287,52.4146381687,10.8051931858,7545.315,Wolfsburg,Germany,Europe,"wolfsburg, hotel, elevator",a second recording of the same elevator - now driving downwards<br /><br />soundmap d - social ambiences and topographic field recordings
+2025-11-06T17:24:50.714426,hello,aporee_2378_3344,/home/zhangrx/SoundingEarth/data/audios/SemforoemfrentedosCorreios.mp3,33.904939,91.493599,40.2115957956073,-8.42737331986427,8391.574,Coimbra,Portugal,Europe,Coimbra: next to main post office - Pedestrian Crossing Song 1,"crossing the road, accompanied by androidlike chirps & burps"

requirements.txt

@@ -1,4 +1,12 @@
-gradio
-numpy
-pandas
-Pillow
+csv
+datetime
+math
+random
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+numpy==2.2.6
+pandas==2.3.3
+pillow==11.3.0
+plotly==6.3.1
+gradio==5.49.1
+gradio_client==1.13.3

requirements2.txt

@@ -0,0 +1,119 @@
+aiofiles==24.1.0
+annotated-doc==0.0.3
+annotated-types==0.7.0
+anyio==4.11.0
+audioread==3.1.0
+branca==0.8.2
+Brotli==1.1.0
+certifi==2025.10.5
+cffi==2.0.0
+charset-normalizer==3.4.4
+choreographer==1.2.0
+click==8.3.0
+contourpy==1.3.2
+cycler==0.12.1
+decorator==5.2.1
+exceptiongroup==1.3.0
+fastapi==0.121.0
+ffmpy==0.6.4
+filelock==3.20.0
+folium==0.20.0
+fonttools==4.60.1
+fsspec==2025.10.0
+gradio==5.49.1
+gradio_client==1.13.3
+groovy==0.1.2
+h11==0.16.0
+hf-xet==1.2.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==1.0.1
+idna==3.11
+iniconfig==2.3.0
+Jinja2==3.1.6
+joblib==1.5.2
+kaleido==1.1.0
+kiwisolver==1.4.9
+lazy_loader==0.4
+librosa==0.11.0
+llvmlite==0.45.1
+logistro==2.0.1
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+matplotlib==3.10.7
+mdurl==0.1.2
+mpmath==1.3.0
+msgpack==1.1.2
+narwhals==2.10.1
+networkx==3.4.2
+numba==0.62.1
+numpy==2.2.6
+nvidia-cublas-cu12==12.8.4.1
+nvidia-cuda-cupti-cu12==12.8.90
+nvidia-cuda-nvrtc-cu12==12.8.93
+nvidia-cuda-runtime-cu12==12.8.90
+nvidia-cudnn-cu12==9.10.2.21
+nvidia-cufft-cu12==11.3.3.83
+nvidia-cufile-cu12==1.13.1.3
+nvidia-curand-cu12==10.3.9.90
+nvidia-cusolver-cu12==11.7.3.90
+nvidia-cusparse-cu12==12.5.8.93
+nvidia-cusparselt-cu12==0.7.1
+nvidia-nccl-cu12==2.27.5
+nvidia-nvjitlink-cu12==12.8.93
+nvidia-nvshmem-cu12==3.3.20
+nvidia-nvtx-cu12==12.8.90
+orjson==3.11.4
+packaging==25.0
+pandas==2.3.3
+pillow==11.3.0
+platformdirs==4.5.0
+plotly==6.3.1
+pluggy==1.6.0
+pooch==1.8.2
+pycparser==2.23
+pydantic==2.11.10
+pydantic_core==2.33.2
+pydub==0.25.1
+Pygments==2.19.2
+pyparsing==3.2.5
+pytest==8.4.2
+pytest-timeout==2.4.0
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.3
+requests==2.32.5
+rich==14.2.0
+ruff==0.14.3
+safehttpx==0.1.7
+safetensors==0.6.2
+scikit-learn==1.7.2
+scipy==1.15.3
+seaborn==0.13.2
+semantic-version==2.10.0
+shellingham==1.5.4
+simplejson==3.20.2
+six==1.17.0
+sniffio==1.3.1
+soundfile==0.13.1
+soxr==1.0.0
+starlette==0.49.3
+sympy==1.14.0
+threadpoolctl==3.6.0
+timm==1.0.21
+tomli==2.3.0
+tomlkit==0.13.3
+torch==2.9.0
+torchvision==0.24.0
+tqdm==4.67.1
+triton==3.5.0
+typer==0.20.0
+typer-slim==0.20.0
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.38.0
+websockets==15.0.1
+xyzservices==2025.10.0