Input Manager – Exploring Input Detection Methods in Unity

Detecting a pressed key (Input.GetKeyDown)

To detect a key press, we use Input.GetKeyDown. This function returns true as soon as the user starts pressing a key.
However, it will not return true until the user has released the key and pressed it again.

        using UnityEngine;

        public class InputMonobehaviour : MonoBehaviour
        {
            private void Update()
            {
                // Using KeyCode
                if (Input.GetKeyDown(KeyCode.Space))
                {
                    // Perform a jump, for example
                }

                // Or with a string
                if (Input.GetKeyDown("space"))
                {
                    // Perform a jump, for example
                }
            }
        }
      

Detecting a released key (Input.GetKeyUp)

Input.GetKeyUpdetects when a key is released. This function returns true during the frame where the user releases the key.
It will not return true otherwise.

        private void Update()
        {
            if (Input.GetKeyUp(KeyCode.Space))
            {
                // The key is released
            }
        }
      

Detecting a held key (Input.GetKey)

We detect a held key withInput.GetKey. This function returns true while the user keeps the specified key pressed.

        private void Update()
        {
            if (Input.GetKey(KeyCode.A))
            {
                // Key A is held, perform an action like shooting
            }
        }
      

Dynamic Key with Input.GetKey()

To use user-defined keys in Input.GetKey, we need to create a system to store user keys.
Below is the code for using “Input.GetKey” with dynamic keys on Unity:

using System;
using System.Collections;
using System.Linq;
using UnityEngine;
using UnityEngine.Events;

public class GetKeySample : MonoBehaviour
{
    public void GetKeyPress(UnityAction<KeyCode> keyCodeAction)
    {
        // You can use async if you prefer
        StartCoroutine(CheckKeyPress(keyCodeAction));
    }

    private IEnumerator CheckKeyPress(UnityAction<KeyCode> keyCodeAction)
    {
        // Get all KeyCode values
        var values = Enum.GetValues(typeof(KeyCode)).Cast<KeyCode>().ToList();

        while (true)
        {
            foreach (var keyCode in values)
            {
                // Check one by one if a key is pressed
                if (Input.GetKeyDown(keyCode))
                {
                    keyCodeAction.Invoke(keyCode);
                    yield break;
                }
            }

            yield return null;
        }
    }

    private void Start()
    {
        // How to use
        GetKeyPress((KeyCode keyCode) =>
        {
            // We can bind keyCode to an action
        });
    }
}
        

This class is a prototype; I think this class would be more usable as a static class without extending MonoBehaviour.

2. Store and Retrieve Keys by Actions

Here, we use PlayerPrefs to store our key preferences.
PlayerPrefs store data locally per machine.
Nothing prevents you from evolving this class to store them on a web server:

using System.Collections.Generic;
using UnityEngine;

public class KeyBinder
{
    // Define all your actions
    public enum Control
    {
        ACTION,
        PARAMETERS,
        MAP
    }

    // Default values can be created in different ways...
    private static Dictionary<Control, KeyCode> _defaultValues = new Dictionary<Control, KeyCode>()
    {
        { Control.ACTION, KeyCode.A },
        { Control.PARAMETERS, KeyCode.Escape },
        { Control.MAP, KeyCode.M }
    };

    // Cache for performance
    private static Dictionary<Control, KeyCode> _keysStored = new Dictionary<Control, KeyCode>();

    public static KeyCode GetKeyCode(Control control)
    {
        // Cached value
        if (_keysStored.ContainsKey(control))
        {
            return _keysStored[control];
        }

        if (PlayerPrefs.HasKey(control.ToString()))
        {
            var value = (KeyCode)PlayerPrefs.GetInt(control.ToString());
            _keysStored.Add(control, value);
            return _keysStored[control];
        }

        // Not configured yet, return the default value
        return _defaultValues[control];
    }

    public static void UpdateKeyControl(Control control, KeyCode keyCode)
    {
        // Remove from cache
        if (_keysStored.ContainsKey(control))
        {
            _keysStored.Remove(control);
        }

        // Update the value
        PlayerPrefs.SetInt(control.ToString(), (int)keyCode);
        PlayerPrefs.Save();
    }
}
        

3. Use these keys in the game

We use the custom “KeyBinder.GetKeyCode” method to retrieve the key associated with our action.
Then, we use “Input.GetKeyDown” to detect a key press.

using UnityEngine;

public class UseKeyBinder : MonoBehaviour
{
    private void Update()
    {
        // Use configured keys
        if (Input.GetKeyDown(KeyBinder.GetKeyCode(KeyBinder.Control.ACTION)))
        {
            // Do something when the ACTION key is pressed
        }
    }
}
        

This system is very flexible and allows you to manage game keys dynamically.

Dynamic Key with Axis

Regarding dynamic axes, it’s another story; we don’t have access to the virtual axes stored in the editor, so we have to create our own axes and replicate their functionality in a new class.

Unfortunately, it is not possible to directly detect the pressure applied to a joystick.
Therefore, all values returned by our customized function will follow the behavior of a regular key and use “sensitivity” to vary the value.

Once again, I recommend switching to the Input System instead of using this code.

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class InputMonobehaviour : MonoBehaviour
{
    // Enum, for detecting which button is pressed
    // Bit field, but we don't need FlagsAttribute because we only use POSITIVE (10) AND NEGATIVE (01)
    public enum PressButton
    {
        NONE,
        POSITIVE,
        NEGATIVE,
        BOTH
    }

    // Recreate a class similar to Virtual Axis Configuration (It will be better as ScriptableObject) 
    public class InputAxis
    {
        public string name;

        public float sensitivity;

        public float gravity;

        public KeyCode negativeKeyCode;

        public KeyCode positiveKeyCode;
    }

    // Let's make it a singleton
    public static InputMonobehaviour Instance { get; private set; }

    private void Awake()
    {
        Instance = this;
    }

    private void Start()
    {
        // Init for sample, ScriptableObject will be better
        // I use static keys for sample but all keys can be changed at runtime.
        _inputAxes = new List<InputAxis>()
        {
            {
                new InputAxis()
                {
                    name = "Vertical",
                    gravity = 3f,
                    sensitivity = 3f,
                    negativeKeyCode = KeyCode.DownArrow,
                    positiveKeyCode = KeyCode.UpArrow
                }
            }
        };
    }

    // Store current axis values
    private static Dictionary<string, float> _axisValues = new Dictionary<string, float>();

    // Store InputAxis in List
    private List<InputAxis> _inputAxes = new List<InputAxis>();

    // This function will replace Input.GetAxis
    public static float GetAxis(string name)
    {
        var axisInput = LoadInputAxis(name);

        // Add key
        if (!_axisValues.ContainsKey(name))
        {
            _axisValues.Add(name, 0f);
        }

        var value = _axisValues[name];

        // Check which button is pressed
        var pressValue = IsPressPositive(axisInput, value);

        // Positive or negative value?
        var sign = Mathf.Sign(value);

        // Nothing is pressed, gravity is applied
        if (pressValue == PressButton.NONE)
        {
            _axisValues[name] = Mathf.Clamp01(Mathf.Abs(value) - Time.deltaTime * axisInput.gravity) * sign;
            return _axisValues[name];
        }

        // Same value is applied in each direction, nothing moves
        if (pressValue == PressButton.BOTH)
        {
            return value;
        }

        var signToFocus = pressValue == PressButton.POSITIVE ? 1f : -1f;

        // It always snaps values, missing a configuration (condition check if the direction has changed)
        if (value != 0 && sign != signToFocus)
        {
            _axisValues[name] = 0f;
            return _axisValues[name];
        }

        _axisValues[name] = Mathf.Clamp01(Mathf.Abs(value) + Time.deltaTime * axisInput.sensitivity) * signToFocus;
        return _axisValues[name];
    }

    private static PressButton IsPressPositive(InputAxis inputAxis, float value)
    {
        // We use PressButton as a field Bit, so we can use bit operations
        PressButton pressPositiveValue = Input.GetKey(inputAxis.positiveKeyCode) ? PressButton.POSITIVE : PressButton.NONE;
        PressButton pressNegativeValue = Input.GetKey(inputAxis.negativeKeyCode) ? PressButton.NEGATIVE : PressButton.NONE;

        return pressPositiveValue | pressNegativeValue;
    }

    private static InputAxis LoadInputAxis(string name)
    {
        return Instance._inputAxes.Single(x => x.name == name);
    }
}
        

3. Use these axes

We use the custom “GetAxis” method to retrieve the value of our axis.

private void Update()
{
    float speed = 3f;
    // Use it like that
    transform.Translate(GetAxis("Vertical") * Time.deltaTime * speed, 0, 0);
}
        

This class is incomplete and has some shortcomings in terms of features and performance.

To briefly explain the code, which may seem complex at first glance: Mathf.Clamp01(Mathf.Abs(value) + Time.deltaTime * axisInput.sensitivity) * signToFocus;

I hope this article has been able to introduce you to new things.

Main image by sergeitokmakov