Fix: dynamic on-screen control hints (#1177)

Previously, on-screen control hints always displayed keyboard icons,
even when the player was using a gamepad. This confused testing, since
players assumed only the keyboard was supported. Gamepad input was
already functional, but hints did not update dynamically.

This change integrates the godot_input_helper addon and refactors input
handling to centralize device detection. On-screen hint scenes now
listen to InputHelper.device_changed and update automatically to show
the correct icons for the last active device (keyboard, PlayStation,
Xbox, Switch, etc.). The mapping API is used so that each action
consistently displays the proper button symbol.

As part of this work:
- shaker.gd was updated to remove redundant _last_controller_id logic.
- input_key.gd was simplified to handle only gamepad input.
- Two new scripts were added:
   - keyboard_input.gd for handling keyboard hints.
- interact_input.gd for managing the interaction button across both
keyboard and gamepad.
- Hint scene scripts were extended to react to device changes and swap
textures dynamically.
- New assets for the main device families were added and wired into the
mapping system.

Success criteria
- Control hints reflect the last active input device (keyboard or
gamepad).
- Switching between devices updates hints immediately.
- Input handling is centralized through InputHelper, with no
duplication.
- No regressions in normal gameplay or input handling.

Fixes #403

---------

Co-authored-by: AlealarcViva <U22200142@utp.edu.pe>

Author: nico-noodle

.pre-commit-config.yaml

@@ -55,5 +55,6 @@ repos:
 exclude: |
   (?x)^(
     addons/dialogue_manager/(.*)|
+    addons/input_helper/(.*)|
     addons/git_describe/(.*)
   )$

REUSE.toml

@@ -43,6 +43,11 @@ path = "addons/git_describe/**"
 SPDX-FileCopyrightText = "Joseph Michael Ware (zibetnu)"
 SPDX-License-Identifier = "MIT"
 
+[[annotations]]
+path = "addons/input_helper/**"
+SPDX-FileCopyrightText = "2022-present Nathan Hoad"
+SPDX-License-Identifier = "MIT"
+
 [[annotations]]
 path = "assets/third_party/xylophone-sampler-pack/*.ogg"
 SPDX-FileCopyrightText = "2013 juancamiloorjuela"
@@ -90,9 +95,7 @@ SPDX-License-Identifier = "CC-BY-SA-4.0"
 
 [[annotations]]
 path = [
-    "assets/third_party/inputs/keyboard-and-mouse/Blanks/*.png",
-    "assets/third_party/inputs/keyboard-and-mouse/Dark/*.png",
-    "assets/third_party/inputs/keyboard-and-mouse/Light/*.png",
+    "assets/third_party/inputs/**/*.png",
 ]
 SPDX-FileCopyrightText = "Nicolae (XELU) Berbece"
 SPDX-License-Identifier = "CC0-1.0"

addons/input_helper/InputHelper.cs

@@ -0,0 +1,287 @@
+using Godot;
+using Godot.Collections;
+
+namespace NathanHoad
+{
+  public static class InputHelper
+  {
+    public delegate void DeviceChangedEventHandler(string device, int deviceIndex);
+    public delegate void KeyboardInputChangedEventHandler(string action, InputEvent input);
+    public delegate void JoypadInputChangedEventHandler(string action, InputEvent input);
+    public delegate void JoypadChangedEventHandler(int deviceIndex, bool isConnected);
+
+    public static DeviceChangedEventHandler? DeviceChanged;
+    public static KeyboardInputChangedEventHandler? KeyboardInputChanged;
+    public static JoypadInputChangedEventHandler? JoypadInputChanged;
+    public static JoypadChangedEventHandler? JoypadChanged;
+
+
+    public const string DEVICE_KEYBOARD = "keyboard";
+    public const string DEVICE_XBOX_CONTROLLER = "xbox";
+    public const string DEVICE_SWITCH_CONTROLLER = "switch";
+    public const string DEVICE_PLAYSTATION_CONTROLLER = "playstation";
+    public const string DEVICE_STEAMDECK_CONTROLLER = "steamdeck";
+    public const string DEVICE_GENERIC = "generic";
+
+    public const string SUB_DEVICE_XBOX_ONE_CONTROLLER = "xbox_one";
+    public const string SUB_DEVICE_XBOX_SERIES_CONTROLLER = "xbox_series";
+    public const string SUB_DEVICE_PLAYSTATION3_CONTROLLER = "playstation3";
+    public const string SUB_DEVICE_PLAYSTATION4_CONTROLLER = "playstation4";
+    public const string SUB_DEVICE_PLAYSTATION5_CONTROLLER = "playstation5";
+    public const string SUB_DEVICE_SWITCH_JOYCON_LEFT_CONTROLLER = "switch_left_joycon";
+    public const string SUB_DEVICE_SWITCH_JOYCON_RIGHT_CONTROLLER = "switch_right_joycon";
+
+
+    private static Node instance;
+    public static Node Instance
+    {
+      get
+      {
+        if (instance == null)
+        {
+          instance = (Node)Engine.GetSingleton("InputHelper");
+          instance.Connect("device_changed", Callable.From((string device, int deviceIndex) => DeviceChanged?.Invoke(device, deviceIndex)));
+          instance.Connect("keyboard_input_changed", Callable.From((string action, InputEvent input) => KeyboardInputChanged?.Invoke(action, input)));
+          instance.Connect("joypad_input_changed", Callable.From((string action, InputEvent input) => JoypadInputChanged?.Invoke(action, input)));
+          instance.Connect("joypad_changed", Callable.From((int deviceIndex, bool isConnected) => JoypadChanged?.Invoke(deviceIndex, isConnected)));
+        }
+        return instance;
+      }
+    }
+
+
+    public static string Device
+    {
+      get => (string)Instance.Get("device");
+    }
+
+
+    public static int DeviceIndex
+    {
+      get => (int)Instance.Get("device_index");
+    }
+
+
+    public static string LastKnownJoypadDevice
+    {
+      get => (string)Instance.Get("last_known_joypad_device");
+    }
+
+
+    public static string LastKnownJoypadIndex
+    {
+      get => (string)Instance.Get("last_known_joypad_index");
+    }
+
+
+    public static float Deadzone
+    {
+      get => (float)Instance.Get("deadzone");
+      set => Instance.Set("deadzone", value);
+    }
+
+
+    public static int MouseMotionThreshold
+    {
+      get => (int)Instance.Get("mouse_motion_threshold");
+      set => Instance.Set("mouse_motion_threshold", value);
+    }
+
+
+    public static string GetSimplifiedDeviceName(string rawName)
+    {
+      return (string)Instance.Call("get_simplified_device_name", rawName);
+    }
+
+
+    public static string GetDeviceFromEvent(InputEvent @event)
+    {
+      return (string)Instance.Call("get_device_from_event", @event);
+    }
+
+
+    public static int GetDeviceIndexFromEvent(InputEvent @event)
+    {
+      return (int)Instance.Call("get_device_index_from_event", @event);
+    }
+
+
+    public static bool HasJoypad()
+    {
+      return (bool)Instance.Call("has_joypad");
+    }
+
+
+    public static string GuessDeviceName()
+    {
+      return (string)Instance.Call("guess_device_name");
+    }
+
+
+    public static void ResetAllActions()
+    {
+      Instance.Call("reset_all_actions");
+    }
+
+
+    public static void SetKeyboardOrJoypadInputForAction(string action, InputEvent input, bool swapIfTaken = true)
+    {
+      Instance.Call("set_keyboard_or_joypad_input_for_action", action, input, swapIfTaken);
+    }
+
+
+    public static InputEvent GetKeyboardOrJoypadInputForAction(string action, InputEvent input, bool swapIfTaken = true)
+    {
+      return (InputEvent)Instance.Call("get_keyboard_or_joypad_input_for_action", action, input, swapIfTaken);
+    }
+
+
+    public static Array<InputEvent> GetKeyboardOrJoypadInputsForAction(string action)
+    {
+      return (Array<InputEvent>)Instance.Call("get_keyboard_or_joypad_inputs_for_action", action);
+    }
+
+
+    public static string GetLabelForInput(InputEvent input)
+    {
+      return (string)Instance.Call("get_label_for_input", input);
+    }
+
+
+    public static string SerializeInputsForAction(string action)
+    {
+      return (string)Instance.Call("serialize_inputs_for_action", action);
+    }
+
+
+    public static string SerializeInputsForActions(Array<string> actions = null)
+    {
+      if (actions == null)
+      {
+        actions = new Array<string>();
+      }
+      return (string)Instance.Call("serialize_inputs_for_actions", actions);
+    }
+
+
+    public static void DeserializeInputsForAction(string action, string serializedInputs)
+    {
+      Instance.Call("desserialize_inputs_for_action", action, serializedInputs);
+    }
+
+    public static void DeserializeInputsForActions(string serializedInputs)
+    {
+      Instance.Call("deserialize_inputs_for_actions", serializedInputs);
+    }
+
+
+    #region Keyboard/Mouse
+
+    public static Array<InputEvent> GetKeyboardInputsForAction(string action)
+    {
+      return (Array<InputEvent>)Instance.Call("get_keyboard_inputs_for_action", action);
+    }
+
+
+    public static InputEvent GetKeyboardInputForAction(string action)
+    {
+      return (InputEvent)Instance.Call("get_keyboard_input_for_action", action);
+    }
+
+
+    public static void SetKeyboardInputForAction(string action, InputEvent input, bool swapIfTaken = true)
+    {
+      Instance.Call("set_keyboard_input_for_action", action, input, swapIfTaken);
+    }
+
+
+    public static void ReplaceKeyboardInputForAction(string action, InputEvent currentInput, InputEvent input, bool swapIfTaken = true)
+    {
+      Instance.Call("replace_keyboard_input_for_action", action, currentInput, input, swapIfTaken);
+    }
+
+
+    public static void ReplaceKeyboardInputAtIndex(string action, int index, InputEvent input, bool swapIfTaken = true)
+    {
+      Instance.Call("replace_keyboard_input_at_index", action, index, input, swapIfTaken);
+    }
+
+    #endregion
+
+
+    #region Joypad
+
+    public static Array<InputEvent> GetJoypadInputsForAction(string action)
+    {
+      return (Array<InputEvent>)Instance.Call("get_joypad_inputs_for_action", action);
+    }
+
+
+    public static InputEvent GetJoypadInputForAction(string action)
+    {
+      return (InputEvent)Instance.Call("get_joypad_input_for_action", action);
+    }
+
+
+    public static void SetJoypadInputForAction(string action, InputEvent input, bool swapIfTaken = true)
+    {
+      Instance.Call("set_joypad_input_for_action", action, input, swapIfTaken);
+    }
+
+
+    public static void ReplaceJoypadInputForAction(string action, InputEvent currentInput, InputEvent input, bool swapIfTaken = true)
+    {
+      Instance.Call("replace_joypad_input_for_action", action, currentInput, input, swapIfTaken);
+    }
+
+
+    public static void ReplaceJoypadInputAtIndex(string action, int index, InputEvent input, bool swapIfTaken = true)
+    {
+      Instance.Call("replace_joypad_input_at_index", action, index, input, swapIfTaken);
+    }
+
+
+    public static void RumbleSmall(int targetDevice = 0)
+    {
+      Instance.Call("rumble_small", targetDevice);
+    }
+
+
+    public static void RumbleMedium(int targetDevice = 0)
+    {
+      Instance.Call("rumble_medium", targetDevice);
+    }
+
+
+    public static void RumbleLarge(int targetDevice = 0)
+    {
+      Instance.Call("rumble_large", targetDevice);
+    }
+
+
+    public static void StartRumbleSmall(int targetDevice = 0)
+    {
+      Instance.Call("start_rumble_small", targetDevice);
+    }
+
+
+    public static void StartRumbleMedium(int targetDevice = 0)
+    {
+      Instance.Call("start_rumble_medium", targetDevice);
+    }
+
+
+    public static void StartRumbleLarge(int targetDevice = 0)
+    {
+      Instance.Call("start_rumble_large", targetDevice);
+    }
+
+
+    public static void StopRumble(int targetDevice = 0)
+    {
+      Instance.Call("stop_rumble", targetDevice);
+    }
+
+    #endregion
+  }
+}

addons/input_helper/InputHelper.cs.uid

@@ -0,0 +1 @@
+uid://cfs4dgwrfvb11

addons/input_helper/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-present Nathan Hoad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.