Fix Rust formatting

launcher/src-tauri/src/commands.rs

@@ -155,8 +155,7 @@ pub fn set_instance_fov(state: State<'_, AppState>, instance_id: String, fov: f6
     if !(-1.0..=1.0).contains(&fov) || !fov.is_finite() {
         return Err("FOV must be between 30 and 110 degrees".into());
     }
-    state.settings.write().unwrap().instance_game_options.entry(instance_id).or_default()
-        .insert("fov".into(), format!("{fov:.3}"));
+    state.settings.write().unwrap().instance_game_options.entry(instance_id).or_default().insert("fov".into(), format!("{fov:.3}"));
     state.save_settings().map_err(aerr)
 }
 
@@ -763,14 +762,18 @@ async fn guild_response_error(resp: reqwest::Response, fallback: &str) -> String
 pub async fn request_guild_join(state: State<'_, AppState>, guild_id: String, message: String) -> Res<()> {
     let req = account_api(&state, reqwest::Method::POST, &format!("/guilds/{guild_id}/requests")).await?;
     let resp = req.json(&serde_json::json!({"message": message})).send().await.map_err(err)?;
-    if !resp.status().is_success() { return Err(guild_response_error(resp, "could not request to join guild").await); }
+    if !resp.status().is_success() {
+        return Err(guild_response_error(resp, "could not request to join guild").await);
+    }
     Ok(())
 }
 
 #[tauri::command]
 pub async fn get_guild_join_requests(state: State<'_, AppState>, guild_id: String) -> Res<serde_json::Value> {
     let resp = account_api(&state, reqwest::Method::GET, &format!("/guilds/{guild_id}/requests")).await?.send().await.map_err(err)?;
-    if !resp.status().is_success() { return Err(guild_response_error(resp, "could not load guild requests").await); }
+    if !resp.status().is_success() {
+        return Err(guild_response_error(resp, "could not load guild requests").await);
+    }
     resp.json().await.map_err(err)
 }
 
@@ -778,44 +781,73 @@ pub async fn get_guild_join_requests(state: State<'_, AppState>, guild_id: Strin
 pub async fn respond_guild_join_request(state: State<'_, AppState>, guild_id: String, uuid: String, accept: bool) -> Res<()> {
     let req = account_api(&state, reqwest::Method::POST, &format!("/guilds/{guild_id}/requests/{uuid}/respond")).await?;
     let resp = req.json(&serde_json::json!({"accept": accept})).send().await.map_err(err)?;
-    if !resp.status().is_success() { return Err(guild_response_error(resp, "could not review guild request").await); }
+    if !resp.status().is_success() {
+        return Err(guild_response_error(resp, "could not review guild request").await);
+    }
     Ok(())
 }
 
 #[tauri::command]
 pub async fn get_guild_roles(state: State<'_, AppState>, guild_id: String) -> Res<serde_json::Value> {
     let resp = account_api(&state, reqwest::Method::GET, &format!("/guilds/{guild_id}/roles")).await?.send().await.map_err(err)?;
-    if !resp.status().is_success() { return Err(guild_response_error(resp, "could not load guild roles").await); }
+    if !resp.status().is_success() {
+        return Err(guild_response_error(resp, "could not load guild roles").await);
+    }
     resp.json().await.map_err(err)
 }
 
 #[tauri::command]
 pub async fn create_guild_role(state: State<'_, AppState>, guild_id: String, role: serde_json::Value) -> Res<()> {
-    let resp = account_api(&state, reqwest::Method::POST, &format!("/guilds/{guild_id}/roles")).await?.json(&role).send().await.map_err(err)?;
-    if !resp.status().is_success() { return Err(guild_response_error(resp, "could not create guild role").await); }
+    let resp =
+        account_api(&state, reqwest::Method::POST, &format!("/guilds/{guild_id}/roles")).await?.json(&role).send().await.map_err(err)?;
+    if !resp.status().is_success() {
+        return Err(guild_response_error(resp, "could not create guild role").await);
+    }
     Ok(())
 }
 
 #[tauri::command]
 pub async fn assign_guild_role(state: State<'_, AppState>, guild_id: String, uuid: String, role: String) -> Res<()> {
-    let resp = account_api(&state, reqwest::Method::PUT, &format!("/guilds/{guild_id}/members/{uuid}/role")).await?.json(&serde_json::json!({"role":role})).send().await.map_err(err)?;
-    if !resp.status().is_success() { return Err(guild_response_error(resp, "could not assign guild role").await); }
+    let resp = account_api(&state, reqwest::Method::PUT, &format!("/guilds/{guild_id}/members/{uuid}/role"))
+        .await?
+        .json(&serde_json::json!({"role":role}))
+        .send()
+        .await
+        .map_err(err)?;
+    if !resp.status().is_success() {
+        return Err(guild_response_error(resp, "could not assign guild role").await);
+    }
     Ok(())
 }
 
 #[tauri::command]
 pub async fn delete_guild_role(state: State<'_, AppState>, guild_id: String, role_id: i64) -> Res<()> {
-    let resp = account_api(&state, reqwest::Method::DELETE, &format!("/guilds/{guild_id}/roles/{role_id}")).await?.send().await.map_err(err)?;
-    if !resp.status().is_success() { return Err(guild_response_error(resp, "could not delete guild role").await); }
+    let resp =
+        account_api(&state, reqwest::Method::DELETE, &format!("/guilds/{guild_id}/roles/{role_id}")).await?.send().await.map_err(err)?;
+    if !resp.status().is_success() {
+        return Err(guild_response_error(resp, "could not delete guild role").await);
+    }
     Ok(())
 }
 
 #[tauri::command]
-pub async fn update_guild(state: State<'_, AppState>, guild_id: String, description: String, motd: String, icon_url: String, banner_url: String) -> Res<()> {
-    let resp = account_api(&state, reqwest::Method::PUT, &format!("/guilds/{guild_id}")).await?
+pub async fn update_guild(
+    state: State<'_, AppState>,
+    guild_id: String,
+    description: String,
+    motd: String,
+    icon_url: String,
+    banner_url: String,
+) -> Res<()> {
+    let resp = account_api(&state, reqwest::Method::PUT, &format!("/guilds/{guild_id}"))
+        .await?
         .json(&serde_json::json!({"description":description,"motd":motd,"icon_url":icon_url,"banner_url":banner_url}))
-        .send().await.map_err(err)?;
-    if !resp.status().is_success() { return Err(guild_response_error(resp, "could not update guild").await); }
+        .send()
+        .await
+        .map_err(err)?;
+    if !resp.status().is_success() {
+        return Err(guild_response_error(resp, "could not update guild").await);
+    }
     Ok(())
 }
 
@@ -949,7 +981,13 @@ pub async fn get_guild_wallet(state: State<'_, AppState>, guild_id: String, serv
 }
 
 #[tauri::command]
-pub async fn transfer_guild_wallet(state: State<'_, AppState>, guild_id: String, server_id: i64, amount: f64, withdraw: bool) -> Res<serde_json::Value> {
+pub async fn transfer_guild_wallet(
+    state: State<'_, AppState>,
+    guild_id: String,
+    server_id: i64,
+    amount: f64,
+    withdraw: bool,
+) -> Res<serde_json::Value> {
     let action = if withdraw { "withdraw" } else { "deposit" };
     let req = account_api(&state, reqwest::Method::POST, &format!("/guilds/{guild_id}/wallet/{action}")).await?;
     let resp = req.json(&serde_json::json!({"server_id":server_id,"amount":amount})).send().await.map_err(err)?;
@@ -1203,7 +1241,6 @@ pub async fn like_user_post(state: State<'_, AppState>, post_id: i64) -> Res<boo
     Ok(body["liked"].as_bool().unwrap_or(false))
 }
 
-
 // ---------------------------------------------------------------------------
 // Map actions and guild invitations
 // ---------------------------------------------------------------------------

launcher/src-tauri/src/game.rs

@@ -228,7 +228,11 @@ pub async fn run(app: AppHandle, instance_id: String, start: bool, deep: bool) -
     let (kill_tx, kill_rx) = tokio::sync::oneshot::channel();
     let run_id = uuid::Uuid::new_v4().to_string();
     state.game.lock().unwrap().push(RunningGame { run_id: run_id.clone(), instance_id: instance_id.clone(), kill: Some(kill_tx) });
-    app.emit("launch://state", StatePayload { instance_id: instance_id.clone(), run_id: Some(run_id.clone()), state: "running".into(), message: None }).ok();
+    app.emit(
+        "launch://state",
+        StatePayload { instance_id: instance_id.clone(), run_id: Some(run_id.clone()), state: "running".into(), message: None },
+    )
+    .ok();
 
     if let Some(window) = app.get_webview_window("main") {
         match settings.after_launch.as_str() {
@@ -337,8 +341,11 @@ pub async fn run(app: AppHandle, instance_id: String, start: bool, deep: bool) -
                 }
             }
         }
-        app2.emit("game://exit", ExitPayload { instance_id: id2.clone(), run_id: run_id2, code, crashed, tail: tail.into_iter().collect(), crash_report })
-            .ok();
+        app2.emit(
+            "game://exit",
+            ExitPayload { instance_id: id2.clone(), run_id: run_id2, code, crashed, tail: tail.into_iter().collect(), crash_report },
+        )
+        .ok();
         emit_state(&app2, &id2, "idle", None);
     });
     Ok(())

launcher/src-tauri/src/telemetry.rs

@@ -23,31 +23,19 @@ pub fn capture(state: &AppState) -> Option<Recorder> {
     let accounts = state.accounts.read().unwrap();
     let active = accounts.active()?;
 
-    Some(Recorder {
-        http: state.http.clone(),
-        panel,
-        token,
-        username: Some(active.username.clone()),
-    })
+    Some(Recorder { http: state.http.clone(), panel, token, username: Some(active.username.clone()) })
 }
 
 impl Recorder {
     pub async fn send(&self, kind: &str, instance: &str) -> anyhow::Result<()> {
-        let mut req = self
-            .http
-            .post(format!("{}/api/v1/launcher/events", self.panel))
-            .timeout(Duration::from_secs(5));
+        let mut req = self.http.post(format!("{}/api/v1/launcher/events", self.panel)).timeout(Duration::from_secs(5));
         if let Some(token) = &self.token {
             req = req.bearer_auth(token);
         }
-        req.json(&LaunchEvent {
-            kind: kind.into(),
-            instance_id: instance.into(),
-            username: self.username.clone(),
-        })
-        .send()
-        .await?
-        .error_for_status()?;
+        req.json(&LaunchEvent { kind: kind.into(), instance_id: instance.into(), username: self.username.clone() })
+            .send()
+            .await?
+            .error_for_status()?;
         Ok(())
     }