Nautilus compatibility for GameInput keybinds

Nitrox.Launcher/Models/Design/ServerEntry.cs

@@ -322,7 +322,21 @@ public async Task StopAsync()
         }
         catch (OperationCanceledException)
         {
-            // ignored
+            // Graceful shutdown timed out, force kill the process
+            Log.Warn($"Server process {LastProcessId} did not stop gracefully within timeout, force killing...");
+            try
+            {
+                using ProcessEx? proc = ProcessEx.GetFirstProcess(GetServerExeName(), ex => ex.Id == LastProcessId);
+                if (proc != null)
+                {
+                    proc.Terminate();
+                    Log.Info($"Server process {LastProcessId} forcefully terminated");
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, $"Failed to force kill server process {LastProcessId}");
+            }
         }
     }
 
@@ -359,18 +373,34 @@ internal async Task ResetCtsAsync(bool cancelPreexisting = false)
                 await Dispatcher.UIThread.InvokeAsync(() => IsServerClosing = true);
                 await Dispatcher.UIThread.InvokeAsync(async () =>
                 {
-                    while (ProcessEx.ProcessExists(GetServerExeName(), ex => ex.Id == LastProcessId))
+                    using CancellationTokenSource shutdownCts = new(TimeSpan.FromSeconds(10));
+                    try
                     {
-                        try
-                        {
-                            await CommandQueue.Writer.WriteAsync("quit");
-                            CommandQueue.Writer.TryComplete();
-                        }
-                        catch (ChannelClosedException)
+                        while (ProcessEx.ProcessExists(GetServerExeName(), ex => ex.Id == LastProcessId))
                         {
-                            await Task.Delay(500);
+                            try
+                            {
+                                await CommandQueue.Writer.WriteAsync("quit", shutdownCts.Token);
+                                CommandQueue.Writer.TryComplete();
+                            }
+                            catch (ChannelClosedException)
+                            {
+                                await Task.Delay(500, shutdownCts.Token);
+                            }
+                            catch (OperationCanceledException)
+                            {
+                                // Timeout reached, force terminate
+                                Log.Warn($"Server {Name} did not respond to quit command, attempting force terminate");
+                                using ProcessEx? proc = ProcessEx.GetFirstProcess(GetServerExeName(), ex => ex.Id == LastProcessId);
+                                proc?.Terminate();
+                                break;
+                            }
                         }
                     }
+                    catch (Exception ex)
+                    {
+                        Log.Error(ex, $"Error during server shutdown for {Name}");
+                    }
                     CommandQueue = Channel.CreateUnbounded<string>();
                     IsOnline = false;
                     Output.Clear();

Nitrox.Launcher/Models/Services/ServerService.cs

@@ -247,6 +247,41 @@ public void Dispose()
         serverRefreshCts.Dispose();
         WeakReferenceMessenger.Default.UnregisterAll(this);
         watcher?.Dispose();
+
+        // Stop all embedded servers when launcher closes
+        // Non-embedded servers are left running as they have their own console window
+        lock (serversLock)
+        {
+            List<Task> stopTasks = [];
+            foreach (ServerEntry server in servers)
+            {
+                if (server.IsOnline && server.IsEmbedded && server.Process != null)
+                {
+                    try
+                    {
+                        Log.Info($"Stopping embedded server {server.Name} during launcher shutdown");
+                        stopTasks.Add(server.StopAsync());
+                    }
+                    catch (Exception ex)
+                    {
+                        Log.Error(ex, $"Error stopping server {server.Name} during shutdown");
+                    }
+                }
+            }
+
+            // Wait for all servers to stop with a timeout
+            if (stopTasks.Count > 0)
+            {
+                try
+                {
+                    Task.WaitAll([.. stopTasks], TimeSpan.FromSeconds(30));
+                }
+                catch (Exception ex)
+                {
+                    Log.Error(ex, "Error waiting for servers to stop during shutdown");
+                }
+            }
+        }
     }
 
     public ServerEntry[] Servers

Nitrox.Model/Helper/Reflect.cs

@@ -77,7 +77,7 @@ public static PropertyInfo Property<T>(Expression<Func<T, object>> expression)
         return (PropertyInfo)GetMemberInfo(expression);
     }
 
-    private static MemberInfo GetMemberInfo(LambdaExpression expression, Type implementingType = null)
+    private static MemberInfo GetMemberInfo(LambdaExpression expression, Type? implementingType = null)
     {
         Expression currentExpression = expression.Body;
         while (true)

Nitrox.Server.Subnautica/Models/Resources/Parsers/PrefabPlaceholderGroupsResource.cs

@@ -147,12 +147,8 @@ private async Task CreateOrLoadPrefabCacheAsync(string nitroxCachePath)
         {
             logger.ZLogWarning($"An error occurred while deserializing the prefab cache. Re-creating it: {ex.Message:@Error}");
         }
-        if (cache.HasValue)
+        if (cache.HasValue && cache.Value.Version == CACHE_VERSION)
         {
-            if (cache.Value.Version != CACHE_VERSION)
-            {
-                logger.ZLogInformation($"Found outdated cache ({cache.Value.Version}, expected {CACHE_VERSION})");
-            }
             prefabPlaceholdersGroupPaths = cache.Value.PrefabPlaceholdersGroupPaths;
             randomPossibilitiesByClassId = cache.Value.RandomPossibilitiesByClassId;
             groupsByClassId = cache.Value.GroupsByClassId;
@@ -162,7 +158,14 @@ private async Task CreateOrLoadPrefabCacheAsync(string nitroxCachePath)
         // Fallback solution
         else
         {
-            logger.ZLogInformation($"Building cache, this may take a while...");
+            if (cache.HasValue)
+            {
+                logger.ZLogInformation($"Found outdated cache ({cache.Value.Version}, expected {CACHE_VERSION}). Rebuilding cache, this may take a while...");
+            }
+            else
+            {
+                logger.ZLogInformation($"Building cache, this may take a while...");
+            }
             // Get all prefab-classIds linked to the (partial) bundle path
             string prefabDatabasePath = Path.Combine(options.Value.GetSubnauticaResourcesPath(), "StreamingAssets", "SNUnmanagedData", "prefabs.db");
             Dictionary<string, string> prefabDatabase = LoadPrefabDatabase(prefabDatabasePath);

Nitrox.Shared.targets

@@ -87,21 +87,13 @@
                  Condition="!Exists('$(OutputDirectory)')"
                  ContinueOnError="WarnAndContinue" />
 
-        <!-- Copy in debug because some systems break when they don't use our assembly resolve to look inside lib folder -->
+        <!-- Copy (don't Move) so dependencies stay in output root. Some code paths load assemblies before/when AssemblyResolve runs or from contexts that don't use it (e.g. Release vs Debug), causing empty UI or missing types when DLLs are only in lib/. -->
         <Copy SourceFiles="@(FilesToMove)"
               DestinationFolder="$(OutputDirectory)"
               OverwriteReadOnlyFiles="True"
               SkipUnchangedFiles="True"
               Retries="3"
               RetryDelayMilliseconds="100"
-              Condition="'$(Configuration)' == 'Debug'"
-              ContinueOnError="ErrorAndContinue" />
-
-        <!-- Move every matching files to OutputDirectory -->
-        <Move SourceFiles="@(FilesToMove)"
-              DestinationFolder="$(OutputDirectory)"
-              OverwriteReadOnlyFiles="True" 
-              Condition="'$(Configuration)' == 'Release'"
               ContinueOnError="ErrorAndContinue" />
     </Target>
 

NitroxClient/MonoBehaviours/Gui/Input/KeyBindings/Actions/ChatKeyBindingAction.cs

@@ -5,7 +5,7 @@ namespace NitroxClient.MonoBehaviours.Gui.Input.KeyBindings.Actions;
 
 public class ChatKeyBindingAction : KeyBinding
 {
-    public ChatKeyBindingAction() : base("Nitrox_Settings_Keybind_OpenChat", "y") { }
+    public ChatKeyBindingAction() : base("Nitrox_Settings_Keybind_OpenChat", "y", "dpad/up") { }
 
     public override void Execute(InputAction.CallbackContext _)
     {

NitroxClient/MonoBehaviours/Gui/Input/KeyBindings/Actions/DiscordFocusBindingAction.cs

@@ -6,7 +6,7 @@ namespace NitroxClient.MonoBehaviours.Gui.Input.KeyBindings.Actions;
 
 public class DiscordFocusBindingAction : KeyBinding
 {
-    public DiscordFocusBindingAction() : base("Nitrox_Settings_Keybind_FocusDiscord", "i") { }
+    public DiscordFocusBindingAction() : base("Nitrox_Settings_Keybind_FocusDiscord", "i", "dpad/down") { }
 
     public override void Execute(InputAction.CallbackContext _)
     {

NitroxPatcher/NitroxPatcher.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
         <TargetFrameworks>net472;net10.0</TargetFrameworks>

NitroxPatcher/Patches/Persistent/Enum_GetValues_Patch.cs

@@ -6,7 +6,9 @@
 namespace NitroxPatcher.Patches.Persistent;
 
 /// <summary>
-/// Specific patch for GameInput.Button enum to return also our own values.
+/// Extends Enum.GetValues() to include Nitrox buttons, which is required for the rebinding UI to recognize them as valid.
+/// Duplicate checking ensures compatibility when Nautilus or other mods also extend the enum.
+/// GameInputSystem_Initialize_Patch also extends GameInput.AllActions (with its own duplicate check) for action creation.
 /// </summary>
 public partial class Enum_GetValues_Patch : NitroxPatch, IPersistentPatch
 {
@@ -18,13 +20,18 @@ public static void Postfix(Type enumType, ref Array __result)
         {
             return;
         }
-
-        GameInput.Button[] result =
+
+        // Check if Nitrox buttons are already in the result (e.g. added by Nautilus or a previous call)
+        int firstNitroxButton = KeyBindingManager.NITROX_BASE_ID;
+        if (__result.Cast<GameInput.Button>().Any(b => (int)b >= firstNitroxButton && (int)b < firstNitroxButton + KeyBindingManager.KeyBindings.Count))
+        {
+            return;
+        }
+
+        __result = (GameInput.Button[])
         [
             .. __result.Cast<GameInput.Button>(),
-            .. Enumerable.Range(KeyBindingManager.NITROX_BASE_ID, KeyBindingManager.KeyBindings.Count).Cast<GameInput.Button>()
+            .. Enumerable.Range(firstNitroxButton, KeyBindingManager.KeyBindings.Count).Cast<GameInput.Button>()
         ];
-
-        __result = result;
     }
 }

NitroxPatcher/Patches/Persistent/GameInputSystem_Initialize_Patch.cs

@@ -1,4 +1,6 @@
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
 using HarmonyLib;
@@ -9,22 +11,93 @@
 namespace NitroxPatcher.Patches.Persistent;
 
 /// <summary>
-/// Inserts Nitrox's keybinds in the new Subnautica input system
+///     Inserts Nitrox's keybinds in the new Subnautica input system.
+///     Extends GameInput.AllActions so the game creates InputAction entries for Nitrox buttons,
+///     which is required for compatibility with Nautilus when both mods run together.
 /// </summary>
-public partial class GameInputSystem_Initialize_Patch : NitroxPatch, IPersistentPatch
+public class GameInputSystem_Initialize_Patch : NitroxPatch, IPersistentPatch
 {
     private static readonly MethodInfo TARGET_METHOD = Reflect.Method((GameInputSystem t) => t.Initialize());
+    private static readonly MethodInfo DEINITIALIZE_METHOD = Reflect.Method((GameInputSystem t) => t.Deinitialize());
+    private static GameInput.Button[] oldAllActions;
 
-    public static void Prefix(GameInputSystem __instance)
+    public override void Patch(Harmony harmony)
     {
-        CachedEnumString<GameInput.Button> actionNames = GameInput.ActionNames;
+        PatchPrefix(harmony, TARGET_METHOD, ((Action<GameInputSystem>)Prefix).Method);
+        PatchTranspiler(harmony, TARGET_METHOD, ((Func<IEnumerable<CodeInstruction>, IEnumerable<CodeInstruction>>)Transpiler).Method);
+        PatchPrefix(harmony, DEINITIALIZE_METHOD, ((Action)DeinitializePrefix).Method);
+    }
 
+    /// <summary>
+    ///     Set the actions callbacks for our own keybindings once they're actually created.
+    ///     If the game didn't create entries (e.g. when AllActions extension doesn't apply to this game version),
+    ///     we create and add the InputActions ourselves, matching Nautilus's approach.
+    /// </summary>
+    private static void RegisterKeybindsActions(GameInputSystem gameInputSystem)
+    {
         int buttonId = KeyBindingManager.NITROX_BASE_ID;
+        foreach (KeyBinding keyBinding in KeyBindingManager.KeyBindings)
+        {
+            GameInput.Button button = (GameInput.Button)buttonId++;
+            if (!gameInputSystem.actions.TryGetValue(button, out InputAction action))
+            {
+                // Game didn't create this action (AllActions may not be used for action creation in this build).
+                // Create and add it ourselves, matching Nautilus's InitializePostfix pattern.
+                string buttonName = GameInput.ActionNames.valueToString.TryGetValue(button, out string name) ? name : button.ToString();
+                action = new InputAction(buttonName, InputActionType.Button);
+                if (!string.IsNullOrEmpty(keyBinding.DefaultKeyboardKey))
+                {
+                    action.AddBinding($"<Keyboard>/{keyBinding.DefaultKeyboardKey}");
+                }
+                if (!string.IsNullOrEmpty(keyBinding.DefaultControllerKey))
+                {
+                    action.AddBinding($"<Gamepad>/{keyBinding.DefaultControllerKey}");
+                }
+                gameInputSystem.actions[button] = action;
+                action.started += gameInputSystem.OnActionStarted;
+                action.Enable();
+            }
+            action.started += keyBinding.Execute;
+        }
+    }
+
+    private static void Prefix(GameInputSystem __instance)
+    {
+        int buttonId = KeyBindingManager.NITROX_BASE_ID;
+        oldAllActions = GameInput.AllActions;
+
+        // Only extend AllActions if Nitrox buttons aren't already present.
+        // AllActions is typically initialized from Enum.GetValues (patched by Enum_GetValues_Patch),
+        // so it may already contain Nitrox buttons. Adding them again would cause duplicate keybinds
+        // in the settings UI since the game builds the binding list from both sources.
+        if (!GameInput.AllActions.Any(b => (int)b >= buttonId && (int)b < buttonId + KeyBindingManager.KeyBindings.Count))
+        {
+            GameInputAccessor.AllActions =
+            [
+                .. GameInput.AllActions,
+                .. Enumerable.Range(buttonId, KeyBindingManager.KeyBindings.Count).Cast<GameInput.Button>()
+            ];
+        }
+
+        CachedEnumString<GameInput.Button> actionNames = GameInput.ActionNames;
+
+        // Access Language.main's internal strings dictionary so we can register "Option{buttonId}"
+        // entries for the binding conflict dialog (the game formats conflict messages using
+        // "Option" + button.ToString(), which yields "Option1000" for Nitrox buttons).
+        Dictionary<string, string> langStrings = null;
+        if (Language.main != null)
+        {
+            langStrings = (Dictionary<string, string>)AccessTools.Field(typeof(Language), "strings").GetValue(Language.main);
+        }
+
         foreach (KeyBinding keyBinding in KeyBindingManager.KeyBindings)
         {
             GameInput.Button button = (GameInput.Button)buttonId++;
             actionNames.valueToString[button] = keyBinding.ButtonLabel;
 
+            // Register the "Option1000" style key so the conflict dialog shows the translated label
+            langStrings?.TryAdd($"Option{(int)button}", Language.main.Get(keyBinding.ButtonLabel));
+
             if (!string.IsNullOrEmpty(keyBinding.DefaultKeyboardKey))
             {
                 // See GameInputSystem.bindingsKeyboard definition
@@ -38,37 +111,38 @@ public static void Prefix(GameInputSystem __instance)
         }
     }
 
+    private static void DeinitializePrefix()
+    {
+        GameInputAccessor.AllActions = oldAllActions;
+    }
+
     /*
      * Modifying the actions must happen before actionMapGameplay.Enable because that line is responsible
      * for activating the actions callback we'll be setting
-     * 
+     *
      * GameInputSystem_Initialize_Patch.RegisterKeybindsActions(this); <--- [INSERTED LINE]
      * this.actionMapGameplay.Enable();
      */
-    public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
+    private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
     {
-        return new CodeMatcher(instructions).MatchStartForward([
-                                                new(OpCodes.Ldarg_0),
-                                                new(OpCodes.Ldfld),
-                                                new(OpCodes.Callvirt, Reflect.Method((InputActionMap t) => t.Enable()))
-                                            ])
-                                            .Insert([
-                                                new CodeInstruction(OpCodes.Ldarg_0),
-                                                new CodeInstruction(OpCodes.Call, Reflect.Method(() => RegisterKeybindsActions(default)))
-                                            ])
+        return new CodeMatcher(instructions).MatchStartForward(new(OpCodes.Ldarg_0), new(OpCodes.Ldfld), new(OpCodes.Callvirt, Reflect.Method((InputActionMap t) => t.Enable())))
+                                            .Insert(new CodeInstruction(OpCodes.Ldarg_0), new CodeInstruction(OpCodes.Call, Reflect.Method(() => RegisterKeybindsActions(default))))
                                             .InstructionEnumeration();
     }
-
-    /// <summary>
-    /// Set the actions callbacks for our own keybindings once they're actually created only
-    /// </summary>
-    public static void RegisterKeybindsActions(GameInputSystem gameInputSystem)
+
+    private static class GameInputAccessor
     {
-        int buttonId = KeyBindingManager.NITROX_BASE_ID;
-        foreach (KeyBinding keyBinding in KeyBindingManager.KeyBindings)
+        /// <summary>
+        ///     Required because "GameInput.AllActions" is a read only field.
+        /// </summary>
+        private static readonly FieldInfo allActionsField = Reflect.Field(() => GameInput.AllActions);
+
+        public static GameInput.Button[] AllActions
         {
-            GameInput.Button button = (GameInput.Button)buttonId++;
-            gameInputSystem.actions[button].started += keyBinding.Execute;
+            set
+            {
+                allActionsField.SetValue(null, value);
+            }
         }
     }
 }