feat: Launch arguments

src-tauri/src/main.rs

@@ -115,6 +115,8 @@ fn main() {
             find_game_install_location_caller,
             get_flightcore_version_number,
             get_northstar_version_number_caller,
+            northstar::launch_arguments::get_launch_arguments,
+            northstar::launch_arguments::set_launch_arguments,
             check_is_northstar_outdated,
             verify_install_location,
             get_host_os_caller,
@@ -145,7 +147,7 @@ fn main() {
             apply_launcher_pr,
             apply_mods_pr,
             get_launcher_download_link,
-            close_application,
+            close_application
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

src-tauri/src/northstar/launch_arguments.rs

@@ -0,0 +1,34 @@
+#[tauri::command]
+pub fn get_launch_arguments(game_path: &str) -> Result<Vec<String>, ()> {
+    // If file does not exist, we return an empty list
+    let launch_args_path = format!("{}/ns_startup_args.txt", game_path);
+    if !std::path::Path::new(&launch_args_path).exists() {
+        return Ok(vec![]);
+    }
+
+    let data = match std::fs::read_to_string(launch_args_path.clone()) {
+        Ok(content) => content,
+        Err(_) => {
+            return Ok(vec![]);
+        }
+    };
+
+    Ok(data.split_whitespace().map(|arg| arg.to_string()).collect())
+}
+
+#[tauri::command]
+pub fn set_launch_arguments(game_path: &str, arguments: Vec<String>) -> Result<(), String> {
+    // If file does not exist, we return an empty list
+    let launch_args_path = format!("{}/ns_startup_args.txt", game_path);
+    if !std::path::Path::new(&launch_args_path).exists() {
+        return Err("Launch arguments file does not exist.".to_string());
+    }
+
+    match std::fs::write(launch_args_path.clone(), arguments.join(" ")) {
+        Ok(..) => (),
+        Err(_) => return Err("Failed to save launch arguments.".to_string()),
+    }
+
+    log::info!("Launch arguments updated.");
+    Ok(())
+}

src-tauri/src/northstar/mod.rs

@@ -3,6 +3,7 @@
 
 use crate::{check_mod_version_number, constants::CORE_MODS};
 use anyhow::anyhow;
+pub mod launch_arguments;
 
 /// Returns the current Northstar version number as a string
 pub fn get_northstar_version_number(game_path: &str) -> Result<String, anyhow::Error> {

src-vue/src/components/LaunchArgumentsSelector.vue

@@ -0,0 +1,147 @@
+<template>
+    <div :class="containerClasses">
+        <el-tooltip
+            v-for="(argument, index) in arguments"
+            class="box-item"
+            :content="argument.i18nEntry"
+            placement="bottom"
+            :disabled="argument.i18nEntry.length === 0"
+        >
+            <el-check-tag
+                class="fc-launch_arg_tag"
+                :checked="values[index]"
+                @change="onChange(index)"
+            >
+                {{ argument.argumentName }}
+            </el-check-tag>
+        </el-tooltip>
+
+        <!-- User-input tag -->
+        <el-input
+            v-if="inputVisible"
+            ref="InputRef"
+            class="fc-tag__input"
+            v-model="inputValue"
+            size="small"
+            @keyup.enter="handleInputConfirm"
+            @blur="handleInputConfirm"
+        />
+        <el-button v-else class="button-new-tag ml-1" size="small" @click="showInput">
+            + New launch argument
+        </el-button>
+    </div>
+</template>
+
+<script lang="ts">
+import { defineComponent } from 'vue';
+import { LaunchArgument } from '../utils/LaunchArgument';
+import { NorthstarState } from '../utils/NorthstarState';
+import {invoke} from "@tauri-apps/api";
+
+export default defineComponent({
+    name: 'LaunchArgumentsSelector',
+    computed: {
+        arguments(): LaunchArgument[] {
+            const officialArguments = [
+                new LaunchArgument("-disablelogs", "Disable logging and creation of log files"),
+                new LaunchArgument("-vanilla", "Disables Northstar loading"),
+                new LaunchArgument("-northstar", "Enables Northstar loading"),
+                new LaunchArgument("-dedicated", "Starts a dedicated server without video output"),
+                new LaunchArgument("-waitfordebugger", "Waits for debugger to connect before launching game"),
+                new LaunchArgument("-enablechathooks", "Enables the use of chathooks for use by mods"),
+                new LaunchArgument("-noplugins", "Disables the plugin system"),
+                new LaunchArgument("-novid", "Disables startup videos"),
+                new LaunchArgument("-nosound", "Disables all game sounds")
+            ];
+
+            return (this.localCustomArgs.concat(officialArguments))
+                .sort((a, b) => a.argumentName.localeCompare(b.argumentName));
+        },
+        containerClasses(): string {
+            return this.gamePathIsSelected ? 'fc-tags_container' : 'fc-tags_container disabled_container';
+        },
+        gamePathIsSelected(): boolean {
+            return this.$store.state.northstar_state !== NorthstarState.GAME_NOT_FOUND;
+        }
+    },
+    data: () => ({
+        inputValue: '',
+        inputVisible: false,
+
+        values: [] as boolean[],
+        localCustomArgs: [] as LaunchArgument[]
+    }),
+    methods: {
+        onChange(index: number) {
+            this.values[index] = !this.values[index];
+            this.saveLaunchArgumentsToFile();
+        },
+        saveLaunchArgumentsToFile() {
+            const newArgs = this.arguments
+                .filter((value: LaunchArgument, index: number) => {
+                    return this.values[index];
+                })
+                .map((value: LaunchArgument) => value.argumentName)
+
+            invoke<string[]>("set_launch_arguments", {
+                gamePath: this.$store.state.game_path, arguments: newArgs
+            });
+        },
+        showInput() {
+            this.inputVisible = true;
+            this.$nextTick(() => {
+                // @ts-ignore
+                this.$refs.InputRef.input.focus();
+            });
+        },
+        handleInputConfirm() {
+            if (this.inputValue.length !== 0) {
+                const allArgumentsNames: string[] = this.arguments.map(arg => arg.argumentName);
+                if (allArgumentsNames.indexOf(this.inputValue) !== -1) {
+                    console.warn(`Argument "${this.inputValue}" already present, ignoring.`);
+                } else {
+                    const newArgument: LaunchArgument = new LaunchArgument(this.inputValue);
+                    this.localCustomArgs.push( newArgument );
+                    const index: number = allArgumentsNames.indexOf(newArgument.argumentName);
+                    this.values.splice(index, 0, true);
+                    this.saveLaunchArgumentsToFile();
+                }
+            }
+            this.inputVisible = false;
+            this.inputValue = '';
+        },
+    },
+    async mounted() {
+        this.values = this.arguments.map(a => false);
+
+        const fileArgs = await invoke<string[]>("get_launch_arguments", { gamePath: this.$store.state.game_path});
+        this.localCustomArgs = fileArgs.map(arg => new LaunchArgument(arg));
+
+        this.arguments.forEach((argument, index) => {
+            if (fileArgs.includes(argument.argumentName)) {
+                this.values[index] = true;
+            }
+        });
+    }
+});
+</script>
+
+<style scoped>
+.fc-launch_arg_tag {
+    margin: 0 8px 8px 8px;
+    white-space: nowrap;
+}
+
+.fc-tags_container {
+    transform: translateX(-8px);
+}
+
+.disabled_container {
+    pointer-events: none;
+    filter: grayscale();
+}
+
+.fc-tag__input {
+    width: auto;
+}
+</style>

src-vue/src/utils/LaunchArgument.ts

@@ -0,0 +1,9 @@
+export class LaunchArgument {
+    public argumentName: string;
+    public i18nEntry: string;
+
+    constructor(argumentName: string, i18nEntry: string = '') {
+        this.argumentName = argumentName;
+        this.i18nEntry = i18nEntry;
+    }
+}

src-vue/src/views/SettingsView.vue

@@ -16,6 +16,12 @@
                     </el-input>
                 </div>
 
+                <!-- Launch arguments selection -->
+                <div class="fc_parameter__panel">
+                    <h3>Launch arguments</h3>
+                    <launch-arguments-selector/>
+                </div>
+
                 <!-- Thunderstore mods per page configuration -->
                 <div class="fc_parameter__panel">
                     <h3>{{ $t('settings.nb_ts_mods_per_page') }}</h3>
@@ -77,12 +83,14 @@ import { ReleaseCanal } from "../utils/ReleaseCanal";
 import { Store } from 'tauri-plugin-store-api';
 import { showErrorNotification, showNotification } from "../utils/ui";
 import LanguageSelector from "../components/LanguageSelector.vue";
+import LaunchArgumentsSelector from "../components/LaunchArgumentsSelector.vue";
 const persistentStore = new Store('flight-core-settings.json');
 
 export default defineComponent({
     name: "SettingsView",
     components: {
-        LanguageSelector
+        LanguageSelector,
+        LaunchArgumentsSelector
     },
     data() {
         return {