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,40 @@
+#[tauri::command]
+/// This method loads arguments from the ns_startup_args.txt Northstar launch
+/// arguments files, filtering out eventual argument duplicates.
+/// If this file does not exist, this will return an empty array.
+pub fn get_launch_arguments(game_path: &str) -> Result<Vec<String>, ()> {
+    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![]);
+        }
+    };
+
+    let mut arguments = data.split_whitespace()
+        .map(|arg| arg.to_string())
+        .collect::<Vec<_>>();
+    arguments.sort_unstable();
+    arguments.dedup();
+    Ok(arguments)
+}
+
+#[tauri::command]
+/// This method puts an array of arguments into the ns_startup_args.txt Northstar
+/// launch arguments files.
+/// If the ns_startup_args.txt file does not exist, this will create it.
+pub fn set_launch_arguments(game_path: &str, arguments: Vec<String>) -> Result<(), String> {
+    let launch_args_path = format!("{}/ns_startup_args.txt", game_path);
+
+    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,238 @@
+<template>
+    <div>
+        <div :class="containerClasses">
+            <div class="fc-launch_arg_tag_container" 
+                    v-for="(argument, index) in arguments">
+                <!-- Official arguments -->
+                <el-tooltip
+                    v-if="argument.i18nEntry.length !== 0"
+                    class="box-item"
+                    :content="$t(argument.i18nEntry)"
+                    placement="bottom"
+                >
+                    <el-check-tag
+                        :checked="values[index]"
+                        @change="onChange(index)"
+                    >
+                        {{ argument.argumentName }}
+                    </el-check-tag>
+                </el-tooltip>
+
+                <!-- Custom arguments -->
+                <el-tag
+                    v-else
+                    closable
+                    @close="onClose(index, argument.argumentName)"
+                >
+                    {{ argument.argumentName }}
+                </el-tag>
+            </div>
+
+            <!-- User-input tag -->
+            <div class="fc-launch_arg_tag_container">
+                <el-input
+                    v-if="inputVisible"
+                    ref="InputRef"
+                    class="fc-tag__input"
+                    v-model="inputValue"
+                    @keyup.enter="handleInputConfirm"
+                    @blur="handleInputConfirm"
+                />
+                <el-button v-else class="button-new-tag ml-1 fc-tag__input" @click="showInput">
+                    {{ $t('settings.launch_args.new_arg_btn') }}
+                </el-button>
+            </div>
+        </div>
+
+
+        <!-- Language selector -->
+        <div :class="containerClasses">
+            <el-select v-if="displayLanguageSelector"
+                v-model="langArgumentValue"
+                class="m-2 fc-launch_arg_tag_container fc-tag__input"
+                :placeholder="$t('settings.launch_args.select_game_language')"
+                @change="onLanguageSelection"
+            >
+                <el-option
+                    v-for="item in langArgumentOptions"
+                    :key="item.value"
+                    :label="item.label"
+                    :value="item.value"
+                />
+            </el-select>
+        </div>
+    </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";
+import { showErrorNotification } from '../utils/ui';
+
+export default defineComponent({
+    name: 'LaunchArgumentsSelector',
+    computed: {
+        arguments(): LaunchArgument[] {
+            return (this.localCustomArgs.concat(this.officialArguments))
+                .sort((a, b) => a.argumentName.localeCompare(b.argumentName));
+        },
+        displayLanguageSelector(): boolean {
+            const langArgPrefix = '-language="';
+            return this.arguments
+                .map(arg => arg.argumentName)
+                .filter(name => name.substring(0, langArgPrefix.length) === langArgPrefix)
+                .length === 0;
+        },
+        officialArguments(): LaunchArgument[] {
+            return [
+                new LaunchArgument("-disablelogs", "settings.launch_args.descriptions.disablelogs"),
+                new LaunchArgument("-vanilla", "settings.launch_args.descriptions.vanilla"),
+                new LaunchArgument("-northstar", "settings.launch_args.descriptions.northstar"),
+                new LaunchArgument("-dedicated", "settings.launch_args.descriptions.dedicated"),
+                new LaunchArgument("-waitfordebugger", "settings.launch_args.descriptions.waitfordebugger"),
+                new LaunchArgument("-enablechathooks", "settings.launch_args.descriptions.enablechathooks"),
+                new LaunchArgument("-noplugins", "settings.launch_args.descriptions.noplugins"),
+                new LaunchArgument("-novid", "settings.launch_args.descriptions.novid"),
+                new LaunchArgument("-nosound", "settings.launch_args.descriptions.nosound")
+            ];
+        },
+        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;
+        },
+        langArgumentOptions() {
+            const languages = ['english', 'french', 'german', 'italian', 'japanese', 'mspanish', 'portuguese', 'russian', 'spanish', 'tchinese'];
+            return languages.map(lang => ({value: lang, label: lang}));
+        }
+    },
+    data: () => ({
+        inputValue: '',
+        inputVisible: false,
+
+        langArgumentValue: '',
+        values: [] as boolean[],
+        localCustomArgs: [] as LaunchArgument[]
+    }),
+    methods: {
+        onLanguageSelection( lang: string ) {
+            this.createNewArgument( `-language="${lang}"` );
+            this.langArgumentValue = '';
+        },
+        createNewArgument(arg: string) {
+            let allArgumentsNames: string[] = this.arguments.map(arg => arg.argumentName);
+            if (allArgumentsNames.indexOf(arg) !== -1) {
+                console.warn(`Argument "${arg}" already present, ignoring.`);
+            } else {
+                const newArgument: LaunchArgument = new LaunchArgument(arg);
+                this.localCustomArgs.push( newArgument );
+                allArgumentsNames = this.arguments.map(arg => arg.argumentName);
+
+                const index: number = allArgumentsNames.indexOf(newArgument.argumentName);
+                this.values.splice(index, 0, true);
+                this.saveLaunchArgumentsToFile();
+            }
+        },
+        onChange(index: number) {
+            this.values[index] = !this.values[index];
+            this.saveLaunchArgumentsToFile();
+        },
+        onClose(index: number, argumentName: string) {
+            // remove item state value
+            this.values.splice(index, 1);
+
+            // remove item from list of custom arguments
+            const localIndex = this.localCustomArgs.map(arg => arg.argumentName).indexOf(argumentName);
+            if (localIndex === -1) {
+                console.error(`Failed removing argument "${argumentName}".`);
+                return;
+            }
+            this.localCustomArgs.splice(localIndex, 1);
+
+            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
+            }).catch((err: any) => {
+                showErrorNotification(err);
+            });
+        },
+        showInput() {
+            this.inputVisible = true;
+            this.$nextTick(() => {
+                // @ts-ignore
+                this.$refs.InputRef.input.focus();
+            });
+        },
+        handleInputConfirm() {
+            if (this.inputValue.length !== 0) {
+                this.createNewArgument(this.inputValue);
+            }
+            this.inputVisible = false;
+            this.inputValue = '';
+        },
+    },
+    async mounted() {
+        this.values = this.arguments.map(a => false);
+
+        // Only add to local arguments those who are not in official arguments array
+        const fileArgs = await invoke<string[]>("get_launch_arguments", { gamePath: this.$store.state.game_path});
+        this.localCustomArgs = fileArgs
+            .filter(arg => this.officialArguments.map(oArg => oArg.argumentName).indexOf(arg) === -1)
+            .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_container {
+    display: inline-block;
+    margin: 0 8px 8px 8px;
+}
+
+.fc-tags_container {
+    transform: translateX(-8px);
+}
+
+.el-tag {
+    background-color: var(--el-color-primary-light-8);
+    color: var(--el-color-primary);
+    font-size: var(--el-font-size-base);
+    line-height: var(--el-font-size-base);
+    padding: 14px 5px 12px 15px;
+    transition: var(--el-transition-all);
+    font-weight: 700;
+}
+
+.el-check-tag {
+    padding: 9px 15px 5px 15px;
+}
+
+.disabled_container {
+    pointer-events: none;
+    filter: grayscale();
+}
+
+.fc-tag__input {
+    width: auto;
+    height: 28px;
+    --el-component-size: 28px;
+}
+</style>

src-vue/src/i18n/lang/en.json

@@ -122,6 +122,23 @@
                 "reinstall_text": "Please wait",
                 "reinstall_success": "Successfully reinstalled Northstar"
             }
+        },
+
+        "launch_args": {
+            "title": "Launch arguments",
+            "new_arg_btn": "+ New launch argument",
+            "select_game_language": "Select game language",
+            "descriptions": {
+                "disablelogs": "Disable logging and creation of log files",
+                "vanilla": "Disables Northstar loading",
+                "northstar": "Enables Northstar loading",
+                "dedicated": "Starts a dedicated server without video output",
+                "waitfordebugger": "Waits for debugger to connect before launching game",
+                "enablechathooks": "Enables the use of chathooks for use by mods",
+                "noplugins": "Disables the plugin system",
+                "novid": "Disables startup videos",
+                "nosound": "Disables all game sounds"
+            }
         }
     },
 

src-vue/src/i18n/lang/fr.json

@@ -122,6 +122,22 @@
                 "reinstall_text": "Veuillez patienter",
                 "reinstall_success": "Northstar réinstallé avec succès"
             }
+        },
+
+        "launch_args": {
+            "title": "Paramètres de démarrage",
+            "new_arg_btn": "+ Nouveau paramètre",
+            "descriptions": {
+                "disablelogs": "Désactive la journalisation et la création de journaux",
+                "vanilla": "Désactive le chargement de Northstar",
+                "northstar": "Active le chargement de Northstar",
+                "dedicated": "Démarre un serveur dédié sans sortie graphique",
+                "waitfordebugger": "Attend la connexion au débuggueur avant de lancer le jeu",
+                "enablechathooks": "Active les chathooks pour les mods",
+                "noplugins": "Désactive le système de plugins",
+                "novid": "Désactive les vidéos au démarrage",
+                "nosound": "Désactive tous les sons du jeu"
+            }
         }
     },
 

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>{{ $t('settings.launch_args.title') }}</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 {