Новая система ввода с устройств в Unity

В этом уроке по системе ввода Unity вы узнаете, как преобразовать ввод с кнопочных устройств в проектах из старого диспетчера ввода в новую систему ввода.

Скачать материалы урока

Версия: C# 7.3, Unity 2020.1, Unity

Обработка входных данных — это основа создания успешной игры. Устройства ввода помогают персонажам игроков выполнять действия в игре, такие как ходьба, прыжки и лазание.

В последнее время было создано много новых платформ, на которых появилось больше устройств ввода Unity. К ним относятся сенсорные экраны, контроллеры VR и геймпады от разных игровых консолей. Если вы хотите, чтобы ваша игра поддерживала разные платформы, вам нужно написать код для обработки логики для разных устройств. Чем больше платформ поддерживается, тем сложнее будет код.

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

В этом уроке вы узнаете:

Особенности новой системы ввода.
Как работает новая система.
Как перенести приложения в новую систему ввода из старого диспетчера ввода.

Материалы для урока были созданы в Unity версии 2020.1. Вы можете скачать эту версию Unity на сайте Unity или установить ее с помощью Unity Hub.

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

Приступая к работе

Сначала скачайте стартовый проект для урока, нажав на кнопку «Скачать материалы урока» вверху страницы. Разархивируйте содержимое и откройте NewUnityInputSystem-Starter в Unity.

После загрузки проекта вы увидите папку RW в окне проекта:

Список файлов проекта в окне Project редактора Unity

Взгляните на организацию папок:

Fonts: шрифты, используемые в сцене.
Materials: Материалы для сцены.
Models: 3D-сетки для персонажей игрока и игрового окружения.
Prefabs: Готовые компоненты, состоящие из скриптов и моделей.
Scenes: Игровая сцена.
Scripts: Скрипты с игровой логикой.
Settings: Файл настроек, в который вы помещаете настройки ввода.
Shaders: Шейдеры для специальных эффектов, таких как тень игрока.
Textures: Графика, используемая материалами и пользовательским интерфейсом.

Стартовый проект — это простой платформер. Вы управляете персонажем игрока, перемещаясь и прыгая, чтобы собирать монеты.

Игра готова к запуску. Откройте GameScene из папки Scenes и нажмите Play, чтобы попробовать поиграть.

В настоящее время элементы управления Move и Jump используют старый Unity Input Manager. Позже в этом руководстве вы узнаете, как использовать новую систему ввода для замены старой.

Что нового в системе ввода Unity

Прежде чем погрузиться в код, ознакомьтесь с функциями новой системы ввода.

Упрощенная архитектура действий и привязки

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

Следующий код, который поддерживает как геймпады, так и клавиатуру, является примером старого способа работы:

bool isGamepad = Input.GetAxis("Gamepad Fire") != 0f;
if (isGamepad)
{
    return Input.GetAxis("Gamepad Fire") >= triggerAxisThreshold;
}
else
{
    return Input.GetButton("Fire");
}

Код использует ветвление if-else для поддержки различных устройств и связанных с ними действий.

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

Событие ввода в новой системе называется action (действием), а отображение между действием и устройством ввода — binding (привязкой).

Сбор информации с помощью инструментов отладки ввода

Система ввода предоставляет новый инструмент под названием Input Debugger. Откройте его, выбрав в меню Window > Analysis > Input Debugger.

Отладчик ввода помогает разработчикам собирать следующую информацию в одном месте:

Состояние системы ввода, включая:

Device: информация о подключенных устройствах.
Layout: какие элементы управления предоставляют эти устройства.
Setting: конфигурация системы ввода.

Он также предоставляет информацию о конкретном устройстве в режиме реального времени. Откройте его, дважды щелкнув на устройство в списке устройств в окне Input Debugger.

Вот демонстрация работы отладчика ввода в действии:

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

Поддержка нескольких устройств и платформ

Благодаря повышенной гибкости новой архитектуры системы ввода Unity может поддерживать множество различных устройств ввода, в том числе:

Клавиатура
Мышь
Ручка
Сенсорный экран
Сенсор
Джойстик
Гэймпад

Примечание. Система ввода также поддерживает устройства, реализующие спецификацию USB HID. Для получения дополнительных сведений ознакомьтесь с документацией по поддерживаемым устройствам Unity.

Понимание новой системы ввода

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

Input Action Assets: файл настроек, содержащий свойства действий и связанных с ними привязок.
Actions: действия определяют логическое значение ввода. Вы можете найти эту информацию в активах входных действий.
Bindings: привязки описывают связь между действием и элементами управления устройства ввода. Вы также найдете эту информацию в объектах Input Action Assets.
PlayerInput: PlayerInput — это скрипт, который управляет событиями действий и связывает их с соответствующей логикой кода.

Иногда легче понять новый рабочий процесс, если вы можете его визуализировать, поэтому взгляните на изображение ниже:

Архитектура новой системы ввода в Unity

Разбейте это на простейшие шаги:

Сначала Unity Engine собирает информацию с подключенных устройств и отправляет соответствующие события, такие как нажатие кнопки, в систему ввода.
Затем система ввода преобразует эти события в действия на основе информации о действии и привязке, хранящейся в активах действия ввода.
Затем он передает действия скрипту PlayerInput, который вызывает соответствующие методы.

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

Установка новой системы ввода

Первое, что вам нужно сделать, это установить новый пакет системы ввода. Стандартная установка Unity не включает его.

Откройте Window > Package Manager в строке меню. Убедитесь, что вы выбрали Unity Registry в раскрывающемся списке пакетов, если вы еще этого не сделали.

Окно Package Manager в редакторе Unity

Найдите Input System в списке. Выберите и нажмите Install.

Создание ассета действия Input

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

Откройте окно Project и выберите Settings из RW. Щелкните правой кнопкой мыши, выберите Create > Input Actions и переименуйте его в MyControl.

Настройка редактора действий

Дважды нажмите на MyControl в настройках, чтобы открыть Action Editor, который помогает управлять действиями и привязками управления.

Окно Action Editor в Unity

Поскольку это новое окно, взгляните на разделы:

Action Maps: группы действий, которые происходят в игре. Вы можете группировать действия для разных целей, таких как игрок, игровой процесс или пользовательский интерфейс.
Actions: список действий и привязок, связанных с выбранной картой действий. На этой панели вы можете создавать, изменять или удалять действия и привязки.
Properties: отредактируйте свойства действия или привязки на этой панели, например тип действия и элементы управления, связанные с привязкой.
Save Assets: это очень важная функция: вы должны нажать Save Assets после внесения любых изменений в Input Action Asset. Если вы забудете сохранить, настройка не сработает. Таким образом, вы не увидите ожидаемого результата и можете подумать, что в коде есть ошибка. Вы можете включить автосохранение, чтобы избежать проблемы, но это довольно медленно.

Теперь вы готовы создать свое первое действие — действие Jump.

Создание действия Jump

Сначала откройте редактор действий и нажмите на значок + в ActionMap, чтобы создать новую карту действий. Переименуйте со значения по умолчанию New Action Map в Player.

Затем на панели Action дважды нажмите на New Action и переименуйте в понятное имя: Jump.

И наконец, вам нужно добавить привязку к действию Jump. Вы свяжете кнопку Spacebar и левую кнопку мыши с этим действием, выполнив следующие действия:

Выберите действие Jump, нажмите на значок + и выберите Add Binding.
Нажмите на новый элемент привязки, <No binding>.
Нажмите на поле Path на панели Binding properties.
Введите Spacebar Keyboard и выберите Space [Keyboard], чтобы создать привязку для клавиши Spacebar.
Повторите шаги 1–3, чтобы создать еще одну привязку для левой кнопки мыши.
Введите Left Button в поле Path и выберите Left Button [Mouse], чтобы создать привязку.

Поздравляем, теперь вы связали действие Jump с клавишей Spacebar на клавиатуре и левой кнопкой мыши.

Теперь соедините эти действия с кодом!

Реализация логики прыжка

Прежде всего, вам нужно удалить из проекта старую логику обработки ввода данных. Откройте Player.cs и перейдите к методу Update ().

void Update()
{
    UpdateAnimation();

    if (!jumping && Input.GetKeyDown(KeyCode.Space))
    {
	HandleJump();
    }
}

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

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

Связывание действия Jump с кодом

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

void Update()
{
    UpdateAnimation();
}

Сохраните скрипт и вернитесь в редактор. Выберите объект Player в иерархии и добавьте компонент PlayerInput из инспектора.

Затем перетащите MyControl в поле Actions компонента PlayerInput. Убедитесь, что в качестве Default Map выбрано Player.

И наконец, откройте Player.cs и добавьте новый метод OnJump () со следующим кодом:

public void OnJump()
{
    HandleJump();
}

Вы связали этот метод с действием Jump, назвав его этим шаблоном: public void On [Action Name Goes Here] ().

Например, действие Jump вызывает OnJump (), а действие Attack вызывает OnAttack ().

Нажмите на Save Asset в редакторе действий и запустите игру. Теперь вы можете использовать пробел или левую кнопку мыши, чтобы заставить персонажа игрока прыгать. Это действительно так просто!

Создание действия перемещения

Вы узнали, как использовать систему ввода для создания действия прыжка. Далее идет действие движения Move! Это действие похоже на Jump, но имеет несколько ключевых отличий.

Например, действие Jump — это простое инициирующее событие, а действие Move — это событие, которое несет в себе значения: направление движения, которое определяется пользовательским вводом.

Опять же, вам нужно создать действие и его привязку. Начните с перехода в редактор действий (дважды нажмите на MyControl, если окно не отображается) и нажмите на значок + на панели действий, чтобы создать новое действие. Переименуйте его в Move.

Затем откройте панель свойств действия, измените Action Type на Value и Control Type на Vector 2.

И наконец, удалите <No Binding>, щелкнув правой кнопкой мыши и выбрав Delete.

Теперь вам нужно создать привязки для действия Move.

Сначала нажмите значок + в заголовке действия Move. Затем выберите Add 2D Vector Composite, чтобы создать четыре элемента привязки, соответствующие направлениям вверх, вниз, влево и вправо.

Up: Up Arrow [Keyboard]
Down: Down Arrow [Keyboard]
Left: Left Arrow [Keyboard]
Right: Right Arrow [Keyboard]

Не забудьте сохранить ассет в редакторе действий!

Реализация логики движения

Перед добавлением новой логики движения вам необходимо удалить реализацию старого ввода Unity.

Откройте Player.cs и перейдите в метод FixedUpdate ():

private void FixedUpdate()
{
    // 1
    float speedX = Input.GetAxisRaw("Horizontal");  // Left, Right
    float speedY = Input.GetAxisRaw("Vertical");  // Back, Forward
    moveVec = new Vector3(speedX, 0, speedY);

    if (jumping == false)
    {
        // 2
        UpdateWhenGrounded();
    }
    else
    {
        // 3
        UpdateWhenJumping();
    }
}

Обратите внимание, что FixedUpdate () вызывается в каждом кадре с фиксированной частотой кадров.

А теперь рассмотрим по порядку:

Input.GetAxisRaw возвращает значение Axis. Input.GetAxisRaw ("Horizontal") дает значение оси X, а Input.GetAxisRaw ("Vertical") дает значение оси Y.
Эти два значения определяют вектор движения moveVec, который вы используете для управления направлением движения игрока.
Логика поведения персонажа игрока на поверхности.
Логика поведения персонажа игрока во время прыжка.

Теперь удалите весь код перед оператором if, чтобы убрать старую логику ввода. Добавьте следующий код над определением класса:

using UnityEngine.InputSystem;

Это позволяет вам получить доступ к значениям из новой системы ввода.

Затем добавьте метод OnMove (), который вызывает действие Move.

public void OnMove(InputValue input)
{
    Vector2 inputVec = input.Get<Vector2>();

    moveVec = new Vector3(inputVec.x, 0, inputVec.y);
}

Когда игрок нажимает клавиши Up, Down, Left и Right, он передает этому методу действие Move вместе со значениями. Вот как нажатие клавиш влияет на значения:

Up: (0, 1)
Down: (0, -1)
Left: (-1, 0)
Right: (1, 0)
No Key: (0, 0)
Up и Left: (1, -1)

InputValue — это новый тип, о котором вы, возможно, не знаете. В этом классе есть метод Get \ (), который можно использовать для доступа к его значениям. В этом случае вы хотите, чтобы 2D-векторный композит, который вы установили в привязке, вычислял вектор движения.

Нажмите Play, чтобы проверить логику.

Обработка действий

Новая система ввода предоставляет четыре способа обработки событий действия.

В этом уроке вы использовали подход SendMessages. Вы можете изменить этот параметр в поле Behavior компонента PlayerInput.

Изменение поведения для обработки ввода в Unity

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

Например, в этом уроке действие Jump вызывает OnJump (), а действие Move вызывает OnMove ().

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

Использование Invoke Unity Events

При использовании Invoke Unity Events (вызов событий Unity) вы настраиваете действие так же, как вы настраиваете нажатие кнопки в Unity UI.

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

Использование Invoke C# Events

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

Вот пример того, как это выглядит:

private void Awake()
{
    animator = GetComponentInChildren<Animator>();
    rigidbody = GetComponent<Rigidbody>();

    // 1
    GetComponent<PlayerInput>().onActionTriggered += HandleAction;
}

private void HandleAction(InputAction.CallbackContext context)
{
    // 2
    if(context.action.name == "Jump")
    {
        HandleJump();
    }
}

Вот что делает этот код:

Получает компонент PlayerInput и регистрирует метод в onActionTriggered.
Управляет тем, какой метод вызывать для различных действий.

Использование цикла обновления новой системы ввода

В старом Unity Input Manager вы проверяли ввод в каждом кадре с помощью метода Update (). В новой системе ввода вы можете задаться вопросом, когда отправляются действия и отправляются ли они перед каждым методом Update ().

В новой системе ввода используется другой цикл обновления, который не зависит от цикла MonoBehaviour. Вы можете узнать больше об этом в документации Unity Execution Order.

Система предлагает три режима обновления для управления циклом обновления. Вы можете настроить их в настройках проекта Project Settings > Input System Package > Update Mode.

Разные методы обновления системы ввода в Unity

Взгляните на каждый из этих узлов:

Dynamic Update: обрабатывает события с нерегулярными интервалами, определяемыми текущей частотой кадров. Это значение по умолчанию.
Fixed Update: обрабатывает события с интервалами фиксированной длины. Time.fixedDeltaTime определяет длину интервала.
Manually: события не обрабатываются автоматически; вы обрабатываете их, когда вызываете InputSystem.Update (). Если вам нужна проверка, аналогичная старой системе, вы можете вызвать InputSystem.Update () в Update ().

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

Куда двигаться дальше?

Скачайте завершенный проект, нажав кнопку «Скачать материалы урока» вверху страницы.

В этом уроке по Unity Input вы узнали:

Базовая схема новой системы ввода.
Как использовать действия и привязки.
Как эффективно обрабатывать различные типы ввода игроков.

Чтобы проверить свои навыки, попробуйте добавить в игру действие Pause.

Чтобы узнать больше о новой системе ввода, вы можете прочитать руководство по системе ввода Unity.

Надеюсь, вам понравился этот урок! Если у вас есть какие-либо вопросы или комментарии, присоединяйтесь к обсуждению.

Автор перевода: Jean Winters

Источник: New Unity Input System: Getting Started

Смотрите также:

Введение в скрипты Unity

Как сделать интерфейс в Юнити для игры Введение в создание пользовательского интерфейса на Unity