Index of every page on this site: llms.txt
All skills
gamedev-skills avatar

/unity-input-system

@c6ca6c4
Run it yourself

Wires Unity 6.3 LTS player input with the Input System package: .inputactions assets, action maps, PlayerInput and control schemes. Use when input does nothing or fires under a menu, FindAction returns null, the old Input class throws, or Input.GetAxis code needs porting. Not for engine-neutral buffering, remapping or deadzones (`input-systems`) or jump feel (`platformer`).

Use this Skill: https://skilld.dev/gh/gamedev-skills/awesome-gamedev-agent-skills/unity-input-system

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈99 tokens for metadata: the name and description. ≈2.1k when used: this file. ≈893 more on demand in 1 file.

Description uses 5.0% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈397 characters, or 5.0%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Unity Input System

Read input through the Input System package (com.unity.inputsystem; Unity 6.3 LTS projects use 1.20.x), which replaces the legacy Input.GetAxis/Input.GetKey Input Manager. Targets Unity 6.3 LTS (6000.3).

When to use

  • Movement, jump and fire input; action maps and control schemes; a PlayerInput component; reading a Vector2 from a stick or WASD; one set of actions for gamepad, keyboard and touch; the Unity rebinding API.
  • Packages/manifest.json lists com.unity.inputsystem, or the project has an *.inputactions asset.

When not to use: input architecture across engines (buffering, remapping screens, dead-zone design) → input-systems; moving the character once you have the vector → unity-physics / unity-csharp-scripting.

Workflow

  1. Read Active Input Handling from the file. ProjectSettings/ProjectSettings.asset has activeInputHandler: 0 (old Input Manager only), 1 (Input System only) or 2 (both). The package receives nothing at 0, and any leftover Input.GetAxis call throws at 1. Grep Assets/ for Input.Get before choosing 1; changing the value restarts the Editor, so tell the user.
  2. Reuse the project-wide actions. New Unity 6 projects usually ship Assets/InputSystem_Actions.inputactions, assigned as project-wide actions, with a Player map (Move, Look, Attack, Interact, Crouch, Jump, Previous, Next, Sprint) and a UI map. Add to it rather than creating a second asset.
  3. Edit the asset as JSON when the Editor is closed. An .inputactions file is JSON: maps[].actions[] (name, type, expectedControlType) and maps[].bindings[] (path such as <Keyboard>/space, action, groups for control schemes, isComposite and isPartOfComposite for WASD). Give each new action and binding a fresh id GUID like the existing entries, keep the file valid JSON, and re-read it after writing.
  4. Choose one way to read it:
    • Project-wide actions in code, InputSystem.actions.FindAction("Player/Move"): no asset reference to wire and the actions start enabled. The default for new code.
    • PlayerInput component when the project already uses it, or for local co-op (PlayerInputManager gives each joining device its own player).
    • An InputActionReference or a separate asset when a tool or system needs its own actions; you Enable() and Disable() them yourself.
  5. Switch action maps for context (gameplay vs menu) instead of guarding every handler.
  6. Verify with the checks below.

Patterns

1. Project-wide actions, polled

using UnityEngine;
using UnityEngine.InputSystem;

public class PlayerControls : MonoBehaviour
{
    private InputAction _move, _jump;

    private void Awake()
    {
        _move = InputSystem.actions.FindAction("Player/Move");
        _jump = InputSystem.actions.FindAction("Player/Jump");
    }

    private void Update()
    {
        Vector2 move = _move.ReadValue<Vector2>();       // continuous value
        if (_jump.WasPressedThisFrame()) { /* jump */ }  // edge, true for one frame
    }
}

2. Callbacks and map switching

private InputActionMap _player, _ui;

private void Awake()
{
    _player = InputSystem.actions.FindActionMap("Player");
    _ui = InputSystem.actions.FindActionMap("UI");
}

private void Start() => _ui.Disable();   // project-wide actions enable every map at startup

private void OnEnable()  => _player.FindAction("Attack").performed += OnAttack;
private void OnDisable() => _player.FindAction("Attack").performed -= OnAttack;

private void OnAttack(InputAction.CallbackContext ctx) { /* attack once per press */ }

public void OpenMenu()  { _player.Disable(); _ui.Enable(); }
public void CloseMenu() { _ui.Disable(); _player.Enable(); }

3. PlayerInput with Send Messages

PlayerInput with Behavior = Send Messages calls On<ActionName>(InputValue) on scripts on the same GameObject: void OnMove(InputValue v) => _move = v.Get<Vector2>();, void OnJump(InputValue v) { if (v.isPressed) Jump(); }. Broadcast Messages also reaches children; Invoke Unity Events and Invoke C# Events need no naming convention.

Verify

  • No Editor needed: parse the .inputactions JSON and confirm every name your code passes to FindAction/FindActionMap exists (for "Player/Jump", a map Player with an action Jump), and that composites have all their parts. Confirm activeInputHandler matches the code.

  • Tests: the package's InputTestFixture adds virtual devices and presses controls from code. List com.unity.inputsystem under "testables" in Packages/manifest.json and add Unity.InputSystem and Unity.InputSystem.TestFramework to the test .asmdef (assembly setup is in unity-csharp-scripting):

    using NUnit.Framework;
    using UnityEngine.InputSystem;
    
    public class JumpInputTests : InputTestFixture
    {
        [Test]
        public void SpaceTriggersJump()
        {
            var keyboard = InputSystem.AddDevice<Keyboard>();
            var jump = new InputAction("Jump", InputActionType.Button, "<Keyboard>/space");
            int performed = 0;
            jump.performed += _ => performed++;
            jump.Enable();
    
            Press(keyboard.spaceKey);
    
            Assert.That(performed, Is.EqualTo(1));
        }
    }
  • Unity CLI with the game running: unity command runtime simulate_key injects a key press (for example Space) through the Input System into the running app, if unity command --query simulate lists it for your target. Read the effect back with unity command script eval, and check the flags with --help.

  • Hardware: ask the user to press the control and report what the Input Debugger (Window > Analysis > Input Debugger) shows for the device and action.

Gotchas

  • No input at all. activeInputHandler is 0, or the action or map was never enabled. Project-wide actions and PlayerInput's default map start enabled; actions from any other asset do not.
  • Gameplay actions fire while a menu is open. Project-wide actions enable every map at startup, including when PlayerInput uses that asset. Disable the maps you do not want in Start (pattern 2).
  • FindAction returns null. The name or Map/Action path does not exist in that asset, or you edited a different asset than the one assigned as project-wide actions (Project Settings > Input System Package).
  • InvalidOperationException about the UnityEngine.Input class. Old Input.GetAxis/ GetKey code runs while activeInputHandler is 1. Port it, or set 2 while you migrate.
  • Buttons read 0 with ReadValue. Presses are edges. Use performed or WasPressedThisFrame(), and read actions in Update: WasPressedThisFrame in FixedUpdate misses presses or sees them twice.
  • Send Messages handlers never fire. The script must be on the same GameObject as the PlayerInput; Broadcast Messages reaches children.
  • Handlers run twice. OnEnable subscribed again without an OnDisable unsubscribe.
  • Touch or gamepad not detected. The device is not in any control scheme the PlayerInput allows, or a 2D Vector composite is missing a part.

References

  • Read references/rebinding.md when adding "press a key to rebind", saving and loading binding overrides, or split-screen local multiplayer with PlayerInputManager.

Related skills

  • input-systems: engine-neutral input architecture, buffering and remapping design.
  • unity-csharp-scripting: the MonoBehaviour around these handlers and test assemblies.
  • unity-physics: applying the input vector to a rigidbody.

Version notes

Last verified: 2026-11-11.

Source: SKILL.md on GitHub

No rule matched.

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts8d3 checks · Risk SAFE
  • Gen Agent Trust Hub9d

    The skill provides instructions for managing the Unity Input System in Unity 6.3 LTS projects. It involves standard developer tasks such as editing JSON configuration files and using Unity CLI tools for input simulation. No malicious patterns or security risks were detected.

  • Socket8d

    No alerts

  • Snyk9d

    Risk: LOW · No issues

Signed by skilld at c6ca6c4. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last week.

Activeupdated last week

README badge

README badge for gamedev-skills/awesome-gamedev-agent-skills/unity-input-system