feat: launch option selector

Author: DecDuck

main/pages/library/[id]/index.vue

@@ -395,6 +395,45 @@
     </template>
   </ModalTemplate>
 
+  <ModalTemplate :model-value="launchOptionsOpen">
+    <template #default>
+      <div class="sm:flex sm:items-start">
+        <div class="mt-3 text-center sm:mt-0 sm:text-left">
+          <h3 class="text-base font-semibold text-zinc-100">
+            Launch {{ game.mName }}
+          </h3>
+          <div class="mt-2">
+            <p class="text-sm text-zinc-400">
+              The instance admin has configured multiple ways to start this
+              game. Select an option to start.
+            </p>
+          </div>
+        </div>
+      </div>
+
+      <ol class="space-y-2">
+        <li v-for="(launchData, launchIdx) in launchOptions!">
+          <button class="transition w-full rounded-sm bg-zinc-800 inline-flex items-center text-sm py-2 px-3 gap-x-2 text-zinc-100 hover:text-zinc-300 hover:bg-zinc-700" @click="() => launchIndex(launchIdx)">
+            <PlayIcon class="size-4" />
+            <span>
+              {{ launchData.name }}
+            </span>
+          </button>
+        </li>
+      </ol>
+    </template>
+    <template #buttons>
+      <button
+        type="button"
+        class="mt-3 inline-flex w-full justify-center rounded-md bg-zinc-800 px-3 py-2 text-sm font-semibold text-zinc-100 shadow-sm ring-1 ring-inset ring-zinc-700 hover:bg-zinc-900 sm:mt-0 sm:w-auto"
+        @click="launchOptions = undefined"
+        ref="cancelButtonRef"
+      >
+        Cancel
+      </button>
+    </template>
+  </ModalTemplate>
+
   <!-- 
   Dear future DecDuck,
   This v-if is necessary for Vue rendering reasons
@@ -492,6 +531,7 @@ import {
   XMarkIcon,
   ArrowsPointingOutIcon,
   PhotoIcon,
+  PlayIcon,
 } from "@heroicons/vue/20/solid";
 import { BuildingStorefrontIcon } from "@heroicons/vue/24/outline";
 import { XCircleIcon } from "@heroicons/vue/24/solid";
@@ -584,9 +624,34 @@ async function resumeDownload() {
   }
 }
 
+const launchOptions = ref<Array<{ name: string }> | undefined>(undefined);
+const launchOptionsOpen = computed(() => launchOptions.value !== undefined);
+
 async function launch() {
   try {
-    await invoke("launch_game", { id: game.value.id });
+    const fetchedLaunchOptions = await invoke<Array<{ name: string }>>(
+      "get_launch_options",
+      { id: game.value.id }
+    );
+    launchOptions.value = fetchedLaunchOptions;
+  } catch (e) {
+    createModal(
+      ModalType.Notification,
+      {
+        title: `Couldn't run "${game.value.mName}"`,
+        description: `Drop failed to launch "${game.value.mName}": ${e}`,
+        buttonText: "Close",
+      },
+      (e, c) => c()
+    );
+    console.error(e);
+  }
+}
+
+async function launchIndex(index: number) {
+  launchOptions.value = undefined;
+  try {
+    await invoke("launch_game", { id: game.value.id, index });
   } catch (e) {
     createModal(
       ModalType.Notification,

src-tauri/process/src/process_manager.rs

@@ -2,6 +2,7 @@ use std::{
     collections::HashMap,
     fs::{OpenOptions, create_dir_all},
     io,
+    ops::Index,
     path::PathBuf,
     process::{Command, ExitStatus},
     str::FromStr,
@@ -18,6 +19,7 @@ use dynfmt::Format;
 use dynfmt::SimpleCurlyFormat;
 use games::{library::push_game_update, state::GameStatusManager};
 use log::{debug, info, warn};
+use serde::Serialize;
 use shared_child::SharedChild;
 use tauri::{AppHandle, Emitter as _};
 
@@ -45,6 +47,11 @@ pub struct ProcessManager<'a> {
     app_handle: AppHandle,
 }
 
+#[derive(Serialize)]
+pub struct LaunchOption {
+    name: String,
+}
+
 impl ProcessManager<'_> {
     pub fn new(app_handle: AppHandle) -> Self {
         let log_output_dir = DATA_ROOT_DIR.join("logs");
@@ -207,8 +214,42 @@ impl ProcessManager<'_> {
         process_handler.is_ok()
     }
 
+    pub fn get_launch_options(game_id: String) -> Result<Vec<LaunchOption>, ProcessError> {
+        let db_lock = borrow_db_checked();
+
+        let meta = db_lock
+            .applications
+            .installed_game_version
+            .get(&game_id)
+            .cloned()
+            .ok_or(ProcessError::NotInstalled)?;
+
+        let game_version = db_lock
+            .applications
+            .game_versions
+            .get(&game_id)
+            .ok_or(ProcessError::InvalidID)?
+            .get(&meta.version)
+            .ok_or(ProcessError::InvalidVersion)?;
+
+        let launch_options = game_version
+            .launches
+            .iter()
+            .filter(|v| v.platform == meta.target_platform)
+            .map(|v| LaunchOption {
+                name: v.name.clone(),
+            })
+            .collect::<Vec<LaunchOption>>();
+
+        Ok(launch_options)
+    }
+
     /// Must be called through spawn as it is currently blocking
-    pub fn launch_process(&mut self, game_id: String) -> Result<(), ProcessError> {
+    pub fn launch_process(
+        &mut self,
+        game_id: String,
+        launch_process_index: usize,
+    ) -> Result<(), ProcessError> {
         if self.processes.contains_key(&game_id) {
             return Err(ProcessError::AlreadyRunning);
         }
@@ -292,12 +333,13 @@ impl ProcessManager<'_> {
                 version_name: _,
                 install_dir: _,
             } => {
-                let launch_config = game_version
+                let (_, launch_config) = game_version
                     .launches
                     .iter()
-                    .find(|v| v.platform == target_platform)
+                    .filter(|v| v.platform == target_platform)
+                    .enumerate()
+                    .find(|(i, _)| *i == launch_process_index)
                     .ok_or(ProcessError::NotInstalled)?;
-
                 (
                     launch_config.command.clone(),
                     launch_config.args.clone(),

src-tauri/src/lib.rs

@@ -271,7 +271,8 @@ pub fn run() {
             kill_game,
             toggle_autostart,
             get_autostart_enabled,
-            open_process_logs
+            open_process_logs,
+            get_launch_options
         ])
         .plugin(tauri_plugin_shell::init())
         .plugin(tauri_plugin_dialog::init())

src-tauri/src/process.rs

@@ -1,14 +1,22 @@
 use std::sync::nonpoison::Mutex;
 
-use process::{PROCESS_MANAGER, error::ProcessError};
-use tauri::AppHandle;
+use process::{PROCESS_MANAGER, error::ProcessError, process_manager::{LaunchOption, ProcessManager}};
+use tauri::{AppHandle, Error};
 use tauri_plugin_opener::OpenerExt;
 
 use crate::AppState;
 
+#[tauri::command]
+pub fn get_launch_options(id: String) -> Result<Vec<LaunchOption>, ProcessError> {
+    let launch_options = ProcessManager::get_launch_options(id)?;
+
+    Ok(launch_options)
+}
+
 #[tauri::command]
 pub fn launch_game(
     id: String,
+    index: usize,
     state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<(), ProcessError> {
     let state_lock = state.lock();
@@ -19,7 +27,7 @@ pub fn launch_game(
     //    download_type: DownloadType::Game,
     //};
 
-    match process_manager_lock.launch_process(id) {
+    match process_manager_lock.launch_process(id, index) {
         Ok(()) => {}
         Err(e) => return Err(e),
     }