SCOPENET Map viewer: shared canvas engine, launcher window and claim terrain, admin map card; BlueMap/Vantage UI removed

launcher/src-tauri/src/commands.rs

@@ -635,90 +635,37 @@ pub async fn get_public_servers(state: State<'_, AppState>) -> Res<serde_json::V
     if !resp.status().is_success() {
         return Err("unable to load servers".into());
     }
-    let data: serde_json::Value = resp.json().await.map_err(err)?;
-    let urls = data["servers"]
-        .as_array()
-        .into_iter()
-        .flatten()
-        .filter_map(|s| Some((s["id"].as_i64()?, s["map_address"].as_str()?.to_owned())))
-        .collect();
-    *state.map_urls.lock().unwrap() = urls;
-    Ok(data)
-}
-
-#[derive(Serialize)]
-pub struct MapResource {
-    status: u16,
-    data: Option<String>,
-    etag: Option<String>,
-}
-
-/// Native transport for BlueMap settings and 2D tiles. Only paths under the
-/// BlueMap address supplied by the panel can be fetched.
-#[tauri::command]
-pub async fn fetch_bluemap_resource(state: State<'_, AppState>, server_id: i64, url: String, etag: Option<String>) -> Res<MapResource> {
-    let configured = state.map_urls.lock().unwrap().get(&server_id).cloned().ok_or("map not configured for this server")?;
-    let base = reqwest::Url::parse(&format!("{}/", configured.trim_end_matches('/'))).map_err(err)?;
-    let target = reqwest::Url::parse(&url).map_err(err)?;
-    let root = base.clone();
-    if !matches!(target.scheme(), "http" | "https")
-        || target.origin() != base.origin()
-        || !target.path().starts_with(root.path())
-        || target.username() != ""
-        || target.password().is_some()
-        || target.fragment().is_some()
-    {
-        return Err("map asset is outside the configured BlueMap site".into());
-    }
-    fetch_map_asset(target, etag, None).await
-}
-
-/// What the launcher needs to offer a Live Map button for one game server.
-#[tauri::command]
-pub async fn get_livemap_info(state: State<'_, AppState>, server_id: i64) -> Res<serde_json::Value> {
-    let req = account_api(&state, reqwest::Method::GET, &format!("/servers/{server_id}/livemap")).await?;
-    let resp = req.send().await.map_err(err)?;
-    if !resp.status().is_success() {
-        let body: serde_json::Value = resp.json().await.unwrap_or_default();
-        return Err(body["error"].as_str().unwrap_or("unable to load the live map").to_string());
-    }
     resp.json().await.map_err(err)
 }
 
-async fn fetch_map_asset(target: reqwest::Url, etag: Option<String>, bearer: Option<String>) -> Res<MapResource> {
-    use base64::Engine;
-    if target.as_str().len() > 2048 {
-        return Err("map asset URL is too long".into());
+/// What the SCOPENET Map needs for one game server: which dimensions have tiles, the tile key, and where tiles live (made absolute,
+/// because the map loads them straight from the panel as images).
+#[tauri::command]
+pub async fn get_map_info(state: State<'_, AppState>, server_id: i64) -> Res<serde_json::Value> {
+    let panel = state.panel_url().ok_or("no panel configured")?;
+    let req = account_api(&state, reqwest::Method::GET, &format!("/servers/{server_id}/map")).await?;
+    let resp = req.send().await.map_err(err)?;
+    if !resp.status().is_success() {
+        let body: serde_json::Value = resp.json().await.unwrap_or_default();
+        return Err(body["error"].as_str().unwrap_or("unable to load the map").to_string());
     }
-    let client = reqwest::Client::builder()
-        .redirect(reqwest::redirect::Policy::none())
-        .timeout(std::time::Duration::from_secs(60))
-        .build()
-        .map_err(err)?;
-    let mut request = client.get(target);
-    if let Some(token) = bearer {
-        request = request.bearer_auth(token);
+    let mut info: serde_json::Value = resp.json().await.map_err(err)?;
+    if let Some(base) = info["tile_base"].as_str().map(str::to_owned) {
+        info["tile_base"] = serde_json::json!(format!("{}{}", panel.trim_end_matches('/'), base));
     }
-    if let Some(etag) = etag.filter(|e| e.len() < 256 && !e.contains('\n') && !e.contains('\r')) {
-        request = request.header(reqwest::header::IF_NONE_MATCH, etag);
+    Ok(info)
+}
+
+/// Players now, plus the claims and pins the game server last sent.
+#[tauri::command]
+pub async fn get_map_overlay(state: State<'_, AppState>, server_id: i64) -> Res<serde_json::Value> {
+    let req = account_api(&state, reqwest::Method::GET, &format!("/servers/{server_id}/map/overlay")).await?;
+    let resp = req.send().await.map_err(err)?;
+    if !resp.status().is_success() {
+        let body: serde_json::Value = resp.json().await.unwrap_or_default();
+        return Err(body["error"].as_str().unwrap_or("unable to load the map").to_string());
     }
-    let response = request.send().await.map_err(err)?;
-    let status = response.status().as_u16();
-    let etag = response.headers().get(reqwest::header::ETAG).and_then(|v| v.to_str().ok()).map(str::to_owned);
-    if status == 304 {
-        return Ok(MapResource { status, data: None, etag });
-    }
-    if !response.status().is_success() {
-        return Ok(MapResource { status, data: None, etag });
-    }
-    if response.content_length().is_some_and(|n| n > 64 * 1024 * 1024) {
-        return Err("BlueMap asset exceeds 64 MiB".into());
-    }
-    let bytes = response.bytes().await.map_err(err)?;
-    if bytes.len() > 64 * 1024 * 1024 {
-        return Err("BlueMap asset exceeds 64 MiB".into());
-    }
-    Ok(MapResource { status, data: Some(base64::engine::general_purpose::STANDARD.encode(bytes)), etag })
+    resp.json().await.map_err(err)
 }
 
 // ---------------------------------------------------------------------------

launcher/src-tauri/src/lib.rs

@@ -97,8 +97,8 @@ pub fn run() {
             commands::get_player_stats,
             commands::get_leaderboard,
             commands::get_public_servers,
-            commands::fetch_bluemap_resource,
-            commands::get_livemap_info,
+            commands::get_map_info,
+            commands::get_map_overlay,
             commands::get_my_level,
             commands::get_my_quests,
             commands::get_reward_summaries,

launcher/src-tauri/src/state.rs

@@ -4,7 +4,6 @@ use crate::settings::Settings;
 use scopenet_core::Layout;
 use scopenet_shared::LauncherManifest;
 use std::path::PathBuf;
-use std::collections::HashMap;
 use std::sync::{Mutex, RwLock};
 
 /// Values baked in at build time by CI (see `.github/workflows/release.yml`).
@@ -41,8 +40,6 @@ pub struct AppState {
     pub accounts: RwLock<AccountsFile>,
     pub secrets: Secrets,
     pub manifest: RwLock<Option<LauncherManifest>>,
-    /// BlueMap addresses received from the panel, keyed by linked game server.
-    pub map_urls: Mutex<HashMap<i64, String>>,
     /// Install/launch pipeline in progress (abortable).
     pub task: Mutex<Option<tokio::task::AbortHandle>>,
     pub game: Mutex<Vec<RunningGame>>,
@@ -61,7 +58,6 @@ impl AppState {
             settings: RwLock::new(settings),
             accounts: RwLock::new(accounts),
             manifest: RwLock::new(manifest),
-            map_urls: Mutex::new(HashMap::new()),
             task: Mutex::new(None),
             game: Mutex::new(Vec::new()),
             data_dir,