show connecting

Author: hry-gh

src-tauri/src/byond.rs

@@ -12,6 +12,8 @@ use crate::presence::{ConnectionParams, PresenceManager};
 use std::process::Command;
 #[cfg(target_os = "windows")]
 use std::sync::Arc;
+#[cfg(target_os = "windows")]
+use tauri::Emitter;
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ByondVersionInfo {
     pub version: String,
@@ -202,10 +204,13 @@ pub async fn connect_to_server(
 
     #[cfg(target_os = "windows")]
     {
-        // Get the control server port to include in the connection URL
-        let control_port = app
-            .try_state::<ControlServer>()
-            .map(|s| s.port.to_string());
+        if let Some(control_server) = app.try_state::<ControlServer>() {
+            control_server.reset_connected_flag();
+        }
+
+        app.emit("game-connecting", &server_name).ok();
+
+        let control_port = app.try_state::<ControlServer>().map(|s| s.port.to_string());
 
         // Build query parameters
         let mut query_params = Vec::new();
@@ -260,7 +265,14 @@ pub async fn connect_to_server(
     #[cfg(not(target_os = "windows"))]
     {
         // Suppress unused warnings
-        let _ = (dreamseeker_path, host, port, server_name, access_type, access_token);
+        let _ = (
+            dreamseeker_path,
+            host,
+            port,
+            server_name,
+            access_type,
+            access_token,
+        );
         Err("BYOND is only natively supported on Windows".to_string())
     }
 }

src-tauri/src/control_server.rs

@@ -1,5 +1,7 @@
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::thread;
+use tauri::Emitter;
 #[cfg(feature = "steam")]
 use tauri::Manager;
 use tiny_http::{Response, Server};
@@ -44,6 +46,9 @@ fn preflight_response() -> Response<std::io::Empty> {
 
 pub struct ControlServer {
     pub port: u16,
+
+    #[allow(dead_code)]
+    pub game_connected: Arc<AtomicBool>,
 }
 
 impl ControlServer {
@@ -62,17 +67,29 @@ impl ControlServer {
 
         tracing::info!("Control server started on port {}", port);
 
+        let game_connected = Arc::new(AtomicBool::new(false));
+        let game_connected_clone = Arc::clone(&game_connected);
+
         thread::spawn(move || {
-            Self::run_server(server, app_handle, presence_manager);
+            Self::run_server(server, app_handle, presence_manager, game_connected_clone);
         });
 
-        Ok(Self { port })
+        Ok(Self {
+            port,
+            game_connected,
+        })
+    }
+
+    #[allow(dead_code)]
+    pub fn reset_connected_flag(&self) {
+        self.game_connected.store(false, Ordering::SeqCst);
     }
 
     fn run_server(
         server: Server,
         app_handle: tauri::AppHandle,
         presence_manager: Arc<PresenceManager>,
+        game_connected: Arc<AtomicBool>,
     ) {
         for request in server.incoming_requests() {
             // Handle CORS preflight requests
@@ -94,6 +111,13 @@ impl ControlServer {
 
             tracing::debug!("Control server received request: {}", url.path());
 
+            if !game_connected.swap(true, Ordering::SeqCst) {
+                tracing::info!("Game connected to control server");
+                if let Some(session) = presence_manager.get_game_session() {
+                    app_handle.emit("game-connected", &session.server_name).ok();
+                }
+            }
+
             match url.path() {
                 "/restart" => {
                     Self::handle_restart(request, &app_handle, &presence_manager);

src-tauri/src/lib.rs

@@ -39,6 +39,11 @@ fn get_control_server_port(control_server: tauri::State<'_, control_server::Cont
     control_server.port
 }
 
+#[tauri::command]
+fn kill_game(presence_manager: tauri::State<'_, std::sync::Arc<presence::PresenceManager>>) -> bool {
+    presence_manager.kill_game_process()
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tracing_subscriber::fmt::init();
@@ -72,6 +77,7 @@ pub fn run() {
             get_settings,
             set_auth_mode,
             get_control_server_port,
+            kill_game,
         ]);
     }
 
@@ -92,6 +98,7 @@ pub fn run() {
             get_settings,
             set_auth_mode,
             get_control_server_port,
+            kill_game,
             get_steam_user_info,
             get_steam_auth_ticket,
             cancel_steam_auth_ticket,

src/App.css

@@ -807,3 +807,47 @@ body {
 .settings-button {
   padding: 8px 16px;
 }
+
+/* Game Connection Modal */
+.game-connection-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.9);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 950;
+}
+
+.game-connection-modal {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 32px;
+  padding: 48px 64px;
+  text-align: center;
+}
+
+.game-connection-status {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 24px;
+}
+
+.game-connection-status h2 {
+  color: var(--primary);
+  margin: 0;
+  text-transform: uppercase;
+  letter-spacing: 2px;
+  font-size: 20px;
+}
+
+.game-connection-spinner {
+  width: 60px;
+  height: 60px;
+  border: 4px solid var(--primary-faint);
+  border-top-color: var(--primary);
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+}

src/App.tsx

@@ -6,6 +6,7 @@ import {
   AccountInfo,
   AuthModal,
   ErrorNotifications,
+  GameConnectionModal,
   RelayDropdown,
   ServerItem,
   SettingsModal,
@@ -16,6 +17,7 @@ import {
   ErrorProvider,
   useAuth,
   useError,
+  useGameConnection,
   useRelays,
   useServers,
   useSettings,
@@ -68,6 +70,13 @@ function AppContent() {
     closeSettings,
   } = useSettings();
 
+  const {
+    gameConnectionState,
+    connectedServerName,
+    closeGameConnectionModal,
+    showGameConnectionModal,
+  } = useGameConnection();
+
   const [pendingAutoConnect, setPendingAutoConnect] = useState<string | null>(
     null,
   );
@@ -279,6 +288,12 @@ function AppContent() {
         onAuthModeChange={handleAuthModeChange}
         onClose={closeSettings}
       />
+      <GameConnectionModal
+        visible={showGameConnectionModal}
+        state={gameConnectionState}
+        serverName={connectedServerName}
+        onClose={closeGameConnectionModal}
+      />
 
       <div className="launcher">
         <Titlebar />

src/components/GameConnectionModal.tsx

@@ -0,0 +1,58 @@
+import { invoke } from "@tauri-apps/api/core";
+import { useState } from "react";
+
+export type GameConnectionState = "idle" | "connecting" | "connected";
+
+interface GameConnectionModalProps {
+  visible: boolean;
+  state: GameConnectionState;
+  serverName: string | null;
+  onClose: () => void;
+}
+
+export function GameConnectionModal({
+  visible,
+  state,
+  serverName,
+  onClose,
+}: GameConnectionModalProps) {
+  const [closing, setClosing] = useState(false);
+
+  if (!visible) return null;
+
+  const handleCloseGame = async () => {
+    setClosing(true);
+    try {
+      await invoke("kill_game");
+      onClose();
+    } catch (err) {
+      console.error("Failed to close game:", err);
+    } finally {
+      setClosing(false);
+    }
+  };
+
+  const statusText =
+    state === "connecting"
+      ? `Connecting to ${serverName}...`
+      : `Connected to ${serverName}`;
+
+  return (
+    <div className="game-connection-overlay">
+      <div className="game-connection-modal">
+        <div className="game-connection-status">
+          {state === "connecting" && <div className="game-connection-spinner" />}
+          <h2>{statusText}</h2>
+        </div>
+        <button
+          type="button"
+          className="button"
+          onClick={handleCloseGame}
+          disabled={closing}
+        >
+          {closing ? "Closing..." : "Close Game"}
+        </button>
+      </div>
+    </div>
+  );
+}

src/components/index.ts

@@ -2,6 +2,8 @@ export { AccountInfo } from "./AccountInfo";
 export type { AuthModalState } from "./AuthModal";
 export { AuthModal } from "./AuthModal";
 export { ErrorNotifications } from "./ErrorNotifications";
+export type { GameConnectionState } from "./GameConnectionModal";
+export { GameConnectionModal } from "./GameConnectionModal";
 export { Modal, ModalCloseButton, ModalContent, ModalSpinner } from "./Modal";
 export { RelayDropdown } from "./RelayDropdown";
 export { ServerItem } from "./ServerItem";

src/hooks/index.ts

@@ -1,5 +1,6 @@
 export { useAuth } from "./useAuth";
 export { ErrorProvider, useError } from "./useError";
+export { useGameConnection } from "./useGameConnection";
 export { useRelays } from "./useRelays";
 export { useServers } from "./useServers";
 export { useSettings } from "./useSettings";

src/hooks/useGameConnection.ts

@@ -0,0 +1,40 @@
+import { listen } from "@tauri-apps/api/event";
+import { useCallback, useEffect, useState } from "react";
+import type { GameConnectionState } from "../components";
+
+export function useGameConnection() {
+  const [gameConnectionState, setGameConnectionState] =
+    useState<GameConnectionState>("idle");
+  const [connectedServerName, setConnectedServerName] = useState<string | null>(
+    null
+  );
+
+  useEffect(() => {
+    const unlistenConnecting = listen<string>("game-connecting", (event) => {
+      setGameConnectionState("connecting");
+      setConnectedServerName(event.payload);
+    });
+
+    const unlistenConnected = listen<string>("game-connected", (event) => {
+      setGameConnectionState("connected");
+      setConnectedServerName(event.payload);
+    });
+
+    return () => {
+      unlistenConnecting.then((unlisten) => unlisten());
+      unlistenConnected.then((unlisten) => unlisten());
+    };
+  }, []);
+
+  const closeGameConnectionModal = useCallback(() => {
+    setGameConnectionState("idle");
+    setConnectedServerName(null);
+  }, []);
+
+  return {
+    gameConnectionState,
+    connectedServerName,
+    closeGameConnectionModal,
+    showGameConnectionModal: gameConnectionState !== "idle",
+  };
+}