Управление в Unity: от классики к современности

Классический ввод (Legacy Input Manager) — устаревший

Это система ввода, которая использовалась в Unity на протяжении многих лет. В новых версиях Unity она больше не включена по умолчанию и считается устаревшей. Тем не менее, она по-прежнему работает в проектах, где активирована вручную, и остаётся удобной для обучения благодаря простоте и отсутствию сложной настройки. Большинство старых туториалов ориентируется именно на неё.

Настройки классического ввода находятся в Edit → Project Settings → Input Manager. Там заданы стандартные оси и кнопки, к которым мы обращаемся по имени.

Оси (Axis)

Пример: Input.GetAxis("Horizontal")

Метод возвращает дробное значение в диапазоне от -1 до 1.

• -1 — движение влево
• 0 — нет ввода
• 1 — движение вправо

Это удобно для плавного движения. На клавиатуре Unity имитирует инерцию, а на геймпаде значение зависит от силы наклона стика.

using UnityEngine;

void Update()
{
    float x = Input.GetAxis("Horizontal");
    Debug.Log(x);
}

Кнопки мыши (Mouse) и позиция курсора

Пример: Input.GetMouseButtonDown(0)

Метод принимает номер кнопки мыши:

• 0 — левая кнопка
• 1 — правая кнопка
• 2 — колесо мыши

Существуют три варианта проверки:

• GetMouseButtonDown — срабатывает один раз при нажатии
• GetMouseButtonUp — срабатывает при отпускании
• GetMouseButton — работает каждый кадр, пока кнопка зажата

using UnityEngine;

void Update()
{
    if (Input.GetMouseButtonDown(0))
    {
        Debug.Log("Левая кнопка мыши нажата");
    }
}

Помимо нажатий кнопок, классическая система ввода позволяет получать позицию курсора мыши на экране. Для этого используется свойство Input.mousePosition, которое возвращает координаты курсора в пикселях относительно левого нижнего угла экрана.

Позиция курсора обычно применяется для прицеливания, выбора объектов мышью или определения направления действия. В 2D-играх координаты экрана часто преобразуют в мировые координаты с помощью камеры.

using UnityEngine;

void Update()
{
    Vector3 mouseScreenPos = Input.mousePosition;
    Vector3 mouseWorldPos = Camera.main.ScreenToWorldPoint(mouseScreenPos);

    Debug.Log(mouseWorldPos);
}

Клавиши клавиатуры (Keys)

Пример: Input.GetKeyDown(KeyCode.Space)

Это прямое обращение к конкретной физической клавише через перечисление KeyCode.

Такой способ удобен, когда нужно быстро привязать действие к определённой кнопке — например, Escape для меню или R для перезарядки.

using UnityEngine;

void Update()
{
    if (Input.GetKeyDown(KeyCode.Space))
    {
        Debug.Log("Прыжок");
    }
}

⚠️ Важно:
Если в проекте включена только новая Input System, этот код не будет работать. Для поддержки классического ввода в настройках игрока должен быть установлен режим:
Edit → Project Settings → Player → Active Input Handling → Both

Итог: классический ввод — простой, быстрый и понятный способ работы с управлением, особенно для обучения и прототипов. Однако для современных проектов он считается устаревшим.

Создаём Input Actions (Action Asset)

В новой системе ввода Unity управление описывается через Input Actions — это набор действий игрока (например, движение, прыжок, выстрел), к которым затем привязываются клавиши, кнопки мыши или геймпад.

В некоторых проектах Unity уже создаёт такой файл автоматически — это дефолтная заготовка. Она рабочая, но обычно слишком общая и не подходит для обучения. Поэтому в этом туториале мы сделаем свой ассет с нуля, чтобы понимать каждый шаг.

Создай новый ассет: кликни правой кнопкой мыши в окне Project (в папке Assets) → Create → Input Actions. Назови файл PlayerControls.

Настраиваем движение как вектор (Vector2)

В новой системе ввода движение удобно описывать не отдельными кнопками, а вектором направления. Такой подход сразу подходит и для клавиатуры, и для геймпада, и не требует переписывания логики в будущем.

Выбери созданный Action Asset PlayerControls и дважды кликни по нему, чтобы открыть окно Input Actions Editor.

В левой колонке Action Maps нажми + и создай карту действий с именем Player. В средней колонке Actions нажми + и создай действие Move.

В правой части окна, в настройках действия Move, установи:

• Action Type: Value
• Control Type: Vector2

Это означает, что действие будет возвращать направление движения в виде вектора (x, y), а не просто сигнал «нажато / не нажато».

Теперь добавим привязки клавиш. У действия Move нажми + и выбери Add Up/Down/Left/Right Composite.

Такой Composite объединяет четыре направления в один вектор движения, который Unity собирает автоматически.

Для каждого направления нажми кнопку Listen и просто нажми соответствующую клавишу на клавиатуре:

• Up — W или ↑
• Down — S или ↓
• Left — A или ←
• Right — D или →

В результате Unity сама будет собирать направление движения в один вектор: вверх, вниз, влево, вправо или по диагонали.

Такой способ настройки даёт чистое и универсальное управление. В коде ты будешь получать уже готовое направление движения, не думая о конкретных клавишах.

💡 Не забудь сохранить изменения. После настройки действий и биндингов нажми кнопку Save Asset в правом верхнем углу окна Input Actions Editor, чтобы Unity применила все изменения.

Добавляем действие прыжка (Jump)

Помимо движения, часто требуется отдельное действие, которое срабатывает один раз — например, прыжок. Для этого в Input System используется действие типа Button.

В той же карте действий Player нажми + в колонке Actions и создай новое действие с именем Jump. В его настройках установи Action Type в значение Button.

Затем добавь биндинг и назначь клавишу Space. Удобнее всего сделать это через кнопку Listen, просто нажав пробел на клавиатуре.

Такое действие срабатывает как событие — оно не передаёт направление или величину, а лишь сообщает факт нажатия кнопки.

💡 Не забудь нажать Save Asset, чтобы сохранить добавленное действие и биндинг.

Назначаем Input Actions ассет активным для проекта

В Unity одновременно может быть активен только один Input Actions ассет на весь проект. В новых проектах этим ассетом часто оказывается дефолтный файл, созданный Unity автоматически.

Если ты создаёшь собственный ассет PlayerControls, его нужно назначить как основной для проекта. Иначе Unity продолжит использовать предыдущий (дефолтный) ассет, и управление может не работать ожидаемым образом.

Выбери файл PlayerControls в окне Project. В Inspector нажми кнопку Assign as the Project-wide Input Actions, если она отображается.

💡 Если кнопка Assign as the Project-wide Input Actions не отображается, значит этот ассет уже назначен активным, и дополнительных действий не требуется.

Удаляем дефолтный Input Actions ассет (если он есть)

В новых проектах Unity может автоматически создавать дефолтный Input Actions ассет. Он остаётся в проекте как обычный файл и может содержать действия с теми же именами, что и в нашем ассете PlayerControls.

Из-за этого при выборе событий или действий могут появляться одинаковые названия, что легко приводит к путанице — особенно в обучающих проектах.

Если ты не используешь дефолтный ассет, просто удали его: кликни по файлу правой кнопкой мыши в окне Project и выбери Delete.

После удаления в проекте останется только ассет PlayerControls, и выбор действий станет однозначным.

💡 Удаление дефолтного Input Actions ассета безопасно, если он не используется в проекте. Для этого туториала он не нужен.

Создаём скрипт PlayerInputDemo

Теперь напишем простой скрипт, который будет принимать события из Input System и превращать их в видимое поведение объекта. Мы будем двигать объект напрямую через Transform, без физики, чтобы сосредоточиться именно на работе ввода.

В папке Assets кликни правой кнопкой мыши → Create → MonoBehaviour Script и назови файл PlayerInputDemo. Затем открой его и замени содержимое следующим кодом.

using UnityEngine;
using UnityEngine.InputSystem;

// Этот скрипт принимает ввод из Input System
// и управляет объектом напрямую через Transform
public class PlayerInputDemo : MonoBehaviour
{
    // Скорость движения объекта
    // Значение можно менять в Inspector
    public float moveSpeed = 5f;

    // Здесь мы храним текущее направление движения
    // (например: (-1,0), (1,0), (0,1) или (0,0))
    private Vector2 moveInput;

    // Этот метод вызывается Player Input,
    // когда срабатывает действие Move
    public void OnMove(InputAction.CallbackContext context)
    {
        // Считываем значение Vector2 из Input System
        // Оно описывает направление движения
        moveInput = context.ReadValue<Vector2>();
    }

    // Этот метод вызывается при нажатии кнопки Jump
    public void OnJump(InputAction.CallbackContext context)
    {
        // Проверяем, что действие именно выполнено,
        // а не отменено или в процессе
        if (!context.performed) return;

        // В качестве наглядного эффекта
        // просто поворачиваем объект на 90 градусов
        transform.Rotate(0f, 0f, 90f);
    }

    // Update вызывается каждый кадр
    void Update()
    {
        // Двигаем объект каждый кадр,
        // пока есть ненулевое направление движения
        transform.position +=
            (Vector3)(moveInput * moveSpeed * Time.deltaTime);
    }
}

💡 Что такое InputAction.CallbackContext?
Это «контекст срабатывания» действия из Input Actions ассета. В нём Unity передаёт уже готовые данные ввода — не конкретную клавишу, а значение, которое получилось из твоих настроек (Action Type, Control Type и Bindings).

Как читать данные:
Для значений (Value) мы берём их через ReadValue<T>(): например, Vector2 для движения (Move) или float для оси. Для кнопок (Button) чаще всего важно не значение, а момент срабатывания — поэтому мы проверяем фазу, например context.performed.

Обрати внимание на важный момент: методы OnMove и OnJump не двигают объект напрямую каждый кадр. Они лишь обновляют состояние ввода или реагируют на событие.

Само движение выполняется в Update(). Такой подход делает код более понятным и предсказуемым: ввод сообщает намерение игрока, а логика движения обрабатывается отдельно.

💡 Такой же принцип используется и в более сложных проектах: Input System отвечает за ввод, а игровые системы — за поведение.

Настраиваем управление игрока через Player Input

Для начала создадим простой объект игрока. Добавь в сцену спрайт треугольника: GameObject → 2D Object → Sprite → Triangle. Он будет служить наглядным примером управляемого объекта.

Выбери созданный объект и добавь к нему два компонента: Player Input и PlayerInputDemo.

В компоненте Player Input убедись, что в поле Actions указан ассет PlayerControls (или выбери его вручную).

В поле Default Map установи значение Player. Это имя Action Map, которую мы создали в ассете PlayerControls, и именно она будет активна при запуске сцены.

Параметр Behavior установи в значение Invoke Unity Events. Это означает, что действия из Input System будут вызывать соответствующие события, которые мы можем связать с методами скрипта.

Раскрой раздел Events, затем группу Player. Внутри ты увидишь два события — Move и Jump, которые соответствуют действиям, настроенным в ассете PlayerControls.

В событии Move добавь новый вызов. В качестве объекта выбери созданный объект с треугольником, а в качестве вызываемого метода — OnMove из скрипта PlayerInputDemo.

Аналогично, в событии Jump выбери тот же объект и укажи метод OnJump из скрипта PlayerInputDemo.

Теперь при запуске сцены ты сможешь управлять объектом с помощью клавиш направления, а при нажатии Space — поворачивать его.

Что важно понять про Input System

В этом туториале мы разобрали базовые принципы работы новой Input System. На практике она обладает значительно большими возможностями — поддержкой геймпадов, переназначения клавиш, нескольких контекстов управления и сложных сценариев ввода. Всё это подключается по мере необходимости в конкретном проекте.

Для начала важно запомнить главное: ввод в Unity — это не одна операция, а последовательность шагов.

1. Описание данных ввода.
   Сначала ты указываешь, какой тип данных тебя интересует: кнопка, число, вектор направления и т.д. Это определяется через Action Type и Control Type в Input Actions ассете.
2. Передача данных в код.
   Затем Unity передаёт эти данные в код выбранным способом — через события (Invoke Unity Events), сообщения или прямые колбэки. На этом этапе ввод превращается в понятный сигнал для логики игры.
3. Обработка данных.
   И только после этого ты решаешь, что делать с полученным вводом: двигать объект, вызывать действие, менять состояние или передавать данные дальше в игровые системы.

Такой подход разделяет ответственность: Input System отвечает за получение и интерпретацию ввода, а игровой код — за поведение объектов. Это делает проекты более гибкими и понятными, особенно по мере роста сложности.

💡 Не обязательно использовать все возможности Input System сразу. Для обучения и простых туториалов достаточно понимать эту цепочку шагов — остальное подключается тогда, когда в нём действительно появляется необходимость.

Прямое управление через Input System

Поскольку туториалы на сайте обычно читаются не по порядку, постоянная настройка Input Actions для каждого примера потребовала бы лишнего подготовительного времени. Кроме того, нельзя быть уверенным, что у всех читателей используется одинаковая конфигурация ввода в Unity.

Поэтому зачастую мы будем использовать возможность прямого доступа к устройствам ввода через новую Input System, без предварительной настройки ассетов и Action Maps.

Такой подход не отличается гибкостью и не подходит для сложных проектов, однако он не требует подготовки и позволяет сразу перейти к изучению игровых механик. Это делает его удобным для простых примеров и лёгких прототипов, в том числе для обучающих туториалов.

По сути, этот способ работы напоминает старый Input Manager: мы напрямую запрашиваем состояние клавиатуры и мыши. В большинстве случаев для этого достаточно двух осей движения и ввода с мыши.

Далее мы рассмотрим, как работает такой метод ввода и как использовать его в простых сценариях без дополнительной настройки.

Прямой ввод для большинства туториалов

В обучающих туториалах управление обычно ограничивается базовым набором ввода: движение с помощью WASD или стрелок, одна кнопка действия (обычно Space), позиция курсора мыши и две кнопки мыши — левая и правая.

Для таких сценариев нет необходимости настраивать Input Actions, Action Maps и дополнительные ассеты. Вместо этого можно напрямую обращаться к устройствам ввода через новую Input System.

Не забудь подключить пространство имён новой системы ввода:

using UnityEngine.InputSystem;

После этого ты получаешь прямой доступ к клавиатуре и мыши и можешь считывать их состояние в коде. Такой подход по смыслу близок к старому Input Manager, но использует современный API и не зависит от настроек проекта.

Ниже приведены примеры скриптов для работы с движением, кнопками и позицией мыши при таком способе ввода. Этого набора достаточно для большинства простых прототипов и обучающих примеров.

💡 Прямой ввод удобен для туториалов и быстрых прототипов. Более гибкие возможности Input System (Action Assets, контексты, ремапинг) имеет смысл подключать тогда, когда проект действительно в них нуждается.

Прямой ввод: клавиатура и мышь

Ниже показаны примеры прямого ввода через новую Input System. Этот способ подходит для большинства туториалов и простых прототипов, где требуется базовое управление без предварительной настройки ассетов.

Движение (WASD / стрелки)

Собираем направление движения вручную, аналогично работе осей в старом Input Manager.

using UnityEngine.InputSystem;

float x = 0f;
float y = 0f;

if (Keyboard.current != null)
{
    if (Keyboard.current.aKey.isPressed || Keyboard.current.leftArrowKey.isPressed)
        x -= 1f;

    if (Keyboard.current.dKey.isPressed || Keyboard.current.rightArrowKey.isPressed)
        x += 1f;

    if (Keyboard.current.sKey.isPressed || Keyboard.current.downArrowKey.isPressed)
        y -= 1f;

    if (Keyboard.current.wKey.isPressed || Keyboard.current.upArrowKey.isPressed)
        y += 1f;
}

Vector2 move = new Vector2(x, y);

Позиция курсора мыши

Получаем позицию курсора в экранных координатах.

using UnityEngine.InputSystem;

Vector2 mouseScreenPos = Mouse.current.position.ReadValue();

При необходимости экранные координаты можно преобразовать в мировые с помощью камеры.

Vector3 mouseWorldPos =
    Camera.main.ScreenToWorldPoint(mouseScreenPos);

Кнопки мыши

Проверка нажатий левой и правой кнопки мыши.

using UnityEngine.InputSystem;

if (Mouse.current != null)
{
    if (Mouse.current.leftButton.wasPressedThisFrame)
        Debug.Log("Левая кнопка мыши");

    if (Mouse.current.rightButton.wasPressedThisFrame)
        Debug.Log("Правая кнопка мыши");
}

Пробел (кнопка действия)

Проверка одиночного нажатия клавиши Space.

using UnityEngine.InputSystem;

if (Keyboard.current != null &&
    Keyboard.current.spaceKey.wasPressedThisFrame)
{
    Debug.Log("Пробел нажат");
}

Эти примеры покрывают большинство сценариев управления в обучающих проектах. Логика игры при этом остаётся простой и понятной, а ввод обрабатывается без дополнительной настройки.

Итоги: какой путь выбрать?

Система ввода в Unity прошла большой путь, и выбор подхода сегодня зависит не от «правильности», а от масштаба и целей проекта.

В большинстве уроков на этом сайте будет использоваться Direct Input — прямой опрос клавиатуры и мыши. Это позволяет не тратить время на настройку ассетов в каждом примере и сосредоточиться на самой сути — создании игровой механики.

Важно помнить: не существует «правильного» или «неправильного» способа работы с вводом. Есть тот, который решает задачу эффективно и без лишней сложности в конкретной ситуации.