Unity управление джойстиком android

Традиционный игровой ввод

Unity поддерживает ввод с клавиатуры, джойстика и гейпада.

Виртуальные оси и кнопки могут быть созданны в Input Manager , и конечные пользователи смогут настраивать ввод с клавиатуры на экране конфигурационного диалогового окна.

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

Virtual Axes

Из скриптов все виртуальные оси доступны по их именам.

Каждый проект при создании содержит следующие оси ввода по умолчанию:

• Horizontal и Vertical привязаны к w, a, s, d и клавишам направления.
• Fire1 , Fire2 , Fire3 привязаны к клавишам Control, Option (Alt) и Command соответственно.
• Mouse X и Mouse Y привязаны к перемещениям мыши.
• Window Shake X и Window Shake Y привязаны к перемещению окна.

Добавление новых осей ввода

Если вы желаете добавить новые виртуальные оси, перейдите в меню Edit->Project Settings->Input . Здесь вы можете также изменить настройки каждой оси.

Вы привязываете каждую ось к двум кнопкам на джойстике, мыши или клавиатуре.

Свойство:	Функция:
Name	Имя, используемое для проверки этой оси из скрипта.
Descriptive Name	Имя положительного значения, отображаемое на вкладке Input диалогового окна Configuration в автономных сборках.
Descriptive Negative Name	Имя отрицательного значения, отображаемое на вкладке Input диалогового окна Configuration в автономных сборках.
Negative Button	Кнопка, используемая для смещения значения оси в отрицательном направлении.
Positive Button	Кнопка, используемая для смещения значения оси в положительном направлении.
Alt Negative Button	Альтернативная кнопка, используемая для смещения значения оси в отрицательном направлении.
Alt Positive Button	Альтернативная кнопка, используемая для смещения значения оси в положительном направлении.
Gravity	Скорость в единицах в секунду, с которой ось возвращается в нейтральное положения, когда кнопки не нажаты.
Dead	Размер аналоговой мертвой зоны. Все значения аналоговых устройств, попадающие в этот диапазон, считаются нейтральными.
Sensitivity	Скорость в единицах в секунду, с которой ось движется к заданному значению. Только для цифровых устройств.
Snap	Если включено, значение оси будет сбрасываться в ноль при нажатии кнопки в противоположном направлении.
Invert	Если включено, Negative Buttons будут выдавать положительные значения, и наоборот.
Type	Тип ввода, который будет управлять осью.
Axis	Ось подключенного устройства, которая будет управлять этой осью.
Joy Num	Подключенный джойстик, который будет управлять этой осью.

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

Использование осей ввода из скриптов

Вы можете запросить текущее состояние из скрипта так:

Это в случае ввода с джойстика и клавиатуры.

Однако изменения осей Mouse и Window Shake показывают, насколько мышь или окно сдвинулись по сравнению с последним кадром. Это значит, что они могут быть больше, чем 1 или меньше, чем –1, когда пользователь быстро двигает мышь.

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

Названия кнопок

Чтобы назначить кнопку оси, вам необходимо ввести имя кнопки в свойстве Positive Button или Negative Button в окне Inspector .

Keys (Клавиши)

Названия кнопок следуют этому соглашению:

• Обычные клавиши“: ”a“, ”b“, ”c» …
• Цифровые клавиши: “1”, “2”, “3”, …
• Клавиши стрелок: “up”, “down”, “left”, “right”
• Клавиши цифровой клавиатуры: “[1]”, “[2]”, “[3]”, “[+]”, “[equals]”
• Клавиши модификаторов: “right shift”, “left shift”, “right ctrl”, “left ctrl”, “right alt”, “left alt”, “right cmd”, “left cmd”
• Клавиши мыши: “mouse 0”, “mouse 1”, “mouse 2”, …
• Кнопки джойстика (от любого джойстика): “joystick button 0”, “joystick button 1”, “joystick button 2”, …
• Кнопки джойстика (от заданного джойстика): “joystick 1 button 0”, “joystick 1 button 1”, “joystick 2 button 0”, …
• Специальные клавиши: “backspace”, “tab”, “return”, “escape”, “space”, “delete”, “enter”, “insert”, “home”, “end”, “page up”, “page down”
• Функциональные клавиши: “f1”, “f2”, “f3”, …

Названия, используемые для определения кнопок одни и те же при написании скриптов и в окне Inspector.

Ось может иметь значение от –1 до 1. На нейтральное положение указывает 0. Note also that the keys are accessible using the KeyCode enum parameter.

Источник

Разработка игры в Unity3D под геймпад

Для работы на конкурс была поставлена задача: спроектировать небольшую игру про космос, которую дети будут проходить порядка 8 минут. И было одно но. Детям должно быть интересно!

Так как пожертвовать клавиатурой на управление было слишком жалко (да и не так это интересно), всё управление планировалось сделать через геймпад. О том, как прикрутить в Unity3d геймпад и пойдёт речь.

Немного о проекте

Первое, что пришло в голову про космос, так это управляемый робот. Развивая эту мысль дальше, игра стала про робота, который на Луне должен найти батарейку, чтобы зарядить лазерную станцию и спастись от приближающейся кометы. Разумеется все нужно было делать на время (до 8-ми минут).

(На удивление детям игра понравилась, в том числе за управление, но об этом ниже).

Картография

Для создания карты с небольшими закоулками и большим соответствием Луне, картой является элемент Terrain, с горами, которые нужны как препятствия и ограничения уровня.

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

Управление

Контроль за руками

Так как у робота две руки, как и количество «грибков» в геймпаде, то разумно этим воспользоваться.

И вот тут начинаются сложности. Дело в том, что первый «грибок» работает (хоть и со скрипом) так же, как и «Mouse X» и «Mouse Y», но второй никак не отзывался по нажатию. Тогда, сев за гугл, прочитал о том, как Unity получает входные управляющие данные. Там и лежит ответ на вопрос, как заставить работать второй (правый) «грибок».

Заходим Edit → Project Settings → Input

Нажали? Тогда должен появиться InputManager в окне Inspector

В начале будет 18 входных параметров, но нам нужно больше. Потому у меня 22 (на ось X и ось Y для второго «грибка» геймпада и ещё два, чтобы обособить имя обращения к первому «грибку»).

Дальше по аналогии с движением мышки (Mouse X) заполняем и переименовываем новые входные значения (имя крайне важно, так как в программе именно к нему вы и обращаетесь).

lp_right.transform.Rotate (0, Input.GetAxis («Hor2_j»), 0);
yr += Input.GetAxis («Hor2_j»);

lp_right.transform.Rotate (Input.GetAxis («Vert2_j»),0, 0);
xr += Input.GetAxis («Vert2_j»);

lp_left.transform.Rotate (0, Input.GetAxis («Hor_j»), 0);
yl += Input.GetAxis («Hor_j»);

lp_left.transform.Rotate (Input.GetAxis («Vert_j»),0, 0);
xl += Input.GetAxis («Vert_j»);

Передвижение

Стоит помнить, что передвижение по координатам плохо скажется на игре, так как карта построена на Terrain. Потому было принято решение использовать физику. Это увеличивает интерес прохождения с одной стороны, а с другой решает несколько проблем сразу (неровное перемещение, скачки, вылет за ограждения).

А значит нужен Rigidbody, который нужно поместить на робота, а дальше на ваш вкус (в проекте выставлена масса 100, остальное осталось не тронутым).

В коде будут только два фокуса. Первый — GetComponent(), чтобы работать именно с Rigidbody и Addforce. Второй — математический. Нужно не только знать, куда хочет робот, но и знать, куда он смотрит. Для этого обращаемся к transform.eulerAngles.y, переводим в радианы и берем косинус и синус для координат x и z соответственно.

Как можно заметить, в действиях указаны по две кнопки. Это сделано на случай, если бампера (L1,L2,R1,R2) сломаются/залипнут при многократном использовании.

Время

Для уточнения настоящего времени в Unity можно использовать System.DateTime.Now, чтобы посчитать в секундах, сколько времени прошло от начала дня. Такой способ ограничения времени имеет недостаток — переход часов с 23:59 на 00:00, но так как игра на раз и конкурс будет проходить днем, то можно пренебречь

• Считайте вместе с днем, месяцем и годом. Когда то видел такую функции в TurboC++, которая выдает количество секунд, прошедших с 1 января 1970
• Прочитайте про таймеры и вызывающие функции в C#

Ограничение по времени тогда можно считать, как разницу во времени после запуска скрипта (void Start()) и тем, что сейчас (Update)

Послесловие

Детям игра понравилась, так как робот перемещался с ускорением, чем все охотно пользовались.

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

Надеюсь, что данная статья поможет вам не сидеть до поздней ночи, прикручивая геймпад к вашему проекту!

Источник

Управление в Android играх на Unity

Unity славен возможностью создавать игры кроссплатформенно. Это действительно круто взять и сделать свою игру и на ПК и на телефон, да еще чтобы и в браузере поиграть. И если с браузером и ПК всё понятно, то у новичков случается ступор при взгляде на сенсорный экран. Там же кнопок нет! И мышки. Цель этого туториала – научить вас работать с сенсорным экраном и создавать разные варианты управления: управление одним касанием, несколькими (телефоны же поддерживают мультитач), а также рассмотрим акселерометр и как считывать с него данные.

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

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

Платформенно зависимая компиляция

Вот хочу создать игру, управлять которой можно и в самом редакторе и на телефоне. Это что же, писать дополнительные скрипты и вешать их на каждый управляемый объект?! Звучит страшно. По счастью, красота кроссплатформенности Unity заключается в том что существуют способы определить с какого девайса идет управление и в зависимости от этого решать как будет идти обработка управления. Такая вещь называется платформенно зависимая компиляция. Она представляет собой директивы препроцессора. Задача этих директив – указать, какие участки кода должны выполняться в зависимости от того, с какой платформы работает приложение. Unity предоставляет инструменты как для определения платформ так и для определения версий с которых запускается код.

Мы рассмотрим те пункты, которые непосредственно касаются темы сенсорного управления игрой, а любопытные могут посмотреть остальные варианты в официальной документации Unity. Итак, прежде чем приступать к написанию кода контроллера для мобильных устройств, нужно предусмотреть необходимость проверки игры в редакторе.

Важными директивами есть следующие:

• UNITY_STANDALONE – добавляется для части скриптов, которые выполняются при запуске игры из системы Windows или Linux, или Mac OS X.
• UNITY_WEBGL – работа с WebGL
• UNITY_IOS – будет исполняться код для iOS платформы
• UNITY_ANDROID – директива для платформы Android

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

Итак, как работать с этими директивами препроцессора и платформенно зависимой компиляцией? Синтаксис директив следующий.

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

Также существует директива #elif, которую можно воспринимать как else if. Работает схожим образом. Также отдельно существует директива #else, но она обязательно должна идти последней и после нее обязательно указывать #endif. Возможно это выглядит странно и страшно, но на самом деле это работает по принципу условий if – else в привычном программировании. Только тут присутствует не игровая логика, а скорее логика управления кодом. Итак, пример кода с директивами.

Несколько слов о том, где именно использовать эти директивы. Не пишите важный код внутри одной из директив, иначе не скомпилируется. Дело в том, что тот код, который написан внутри условия, допустим UNITY_IOS, никогда не выполнится при запуске в редакторе. Считайте, что вы просто вырезаете из своего исходного кода части – они никогда не выполнятся. И вот если их отсутствие мешает успешной компиляции, то наверняка этим частям кода не место внутри директивы. Итак, если это понятно, то самое время двигаться вперед к управлению с телефона!

Управление с touchscreen

Природа этого элемента управления несколько иная от клавиатуры и мышки. Скрипты стоит писать с учетом особенностей тачскринов. Поскольку на тачскрине можно зарегистрировать не один, а несколько касаний, то в памяти сохраняется массив, в котором записана информация о каждом касании. В Unity Scripting API за это отвечает класс Input – такой же как и при регистрации ввода с клавиатуры и мыши, однако методы другие.

Основы

Итак, рассмотрим такой сценарий – необходимо зарегистрировать касание одним пальцем на экране. Сначала посмотрим, как узнать позицию касания, а потом – как зарегистрировать касание по игровому объекту. Приступим.

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

Алгоритм состоит из следующий частей:

1. Зарегистрировать хотя бы одно касание
2. Сохранить интересующий нас элемент массива
3. Получить фазу касания экрана и что-то сделать.

И не забываем про директивы и платформенно зависимую компиляцию. Это первое что мы сделаем в коде.

Внутри этой директивы мы имеем право описать управление. Первое – удостовериться,что касание произошло. Input записывает количество касаний в Input.touchCount.

Второе – получить первое в списке касание.Существует объект Touch, который содержит всю информацию об единичном касании. Чтобы получить нужную информацию используем метод Input.GetTouch(). Этот метод принимает как аргумент любое целое число – оно и будет показывать индекс искомого элемента в массиве. Про массивы и то как с ними работать можно найти в любом учебнике по с#. Внутри предыдущего условия пишем:

Отлично, мы получили информацию о касании и сохранили её в переменную. Что мы можем извлечь из этого.

Любые сенсорные экраны могут регистрировать разные данные: фаза касания (начало, движение, окончание), позицию на экране и количество быстрых касаний, а также информацию о поведении (траектория движения и подобное). В примерах будет использоваться имя переменной, которую мы создали в предыдущем этапе, а именно myTouchтипа Touch.

Естественно имя переменной вы можете задавать сами.

1. Фаза касания: их существует несколько. Найти их можно в свойстве myTouch.phase объекта Touch. Представляют собой перечисление TouchPhase. Варианты такие:
   1. Began – произошло начало касания
   2. Moved – пользователь водит пальцем по экрану
   3. Stationary – пользователь касается экрана, но не меняет положения касания
   4. Ended – касание прекратилось
   5. Canceled – система не может считать касание(например пользователь касается ладонью и невозможно определить количество контактов)
2. Позиция на экране. Находится в свойстве myTouch.position. Также существует deltaPosition, которое показывает расстояние между позицией в текущем кадре и в предыдущем. Позиция выводится в координатах экрана, расчет которых проходит с левого нижнего угла.
3. myTouch.tapCount – количество быстрых касаний. Можно использовать для программирования “дабл-клика”. Если касания происходят быстро несколькими пальцами, то они могут быть неправильно считаны, как касание одним пальцем.
4. myTouch.fingerId – значение по которому можно отслеживать касание. Сохраняет свое значение в каждом кадре и поэтому является отличным источником для работы со сложными траекториями движения, анализе жестов. По сути, это уникальный Id для каждого конкретного жеста (не путать с порядковым номером касания). Отлично, с теорией разобрались. Рассмотрим два практических примера.

Пример 1. Получение координат точки на экране, куда пользователь указал в игре.

Тут просто выводится в консоль значение позиции на экране. Позиция на экране задается через Vector2. Однако в консоль будет выводится несколько сообщений, так как одно касание может длиться несколько кадров (мы пишем это в Update). Если нужна только точка в момент касания, то обращаемся к фазам касания. Код будет выглядеть так:

Появилось только условие (выделено желтым).

Пример 2. Касание по объекту на экране. Тут будет использован Raycast.

Направление движения

С основами разобрались, теперь более сложные задачи, которые задаются разработчикам. Одна из таких задач – определение направления, куда пользователь провёл пальцем. Направление будем определять с помощью векторов, а именно – нормализации вектора. В разделе Основы упоминалось о свойстве deltaPosition. Его и будем использовать. Для примера представлен скрипт, который заставляет объект двигаться в заданном направлении бесконечно (или до изменения инструкций)

Мультитач

Для работы с несколькими точками касания на экране необходимо вспомнить про циклы. Помним, что каждый момент касания фиксируется в массиве, а значит, если пройти по всему массиву циклом, то можно получить информацию о каждом касании. В остальном работа не отличается от касания одним пальцем.
Input.touchCount – это количество элементов в массиве. Получение объекта по индексу – myTouches[i]. И с этой конструкцией можно работать также как в предыдущем разделе мы работали с элементами Touch.

Акселерометр

Мобильные устройства позволяют считывать свое положение в трехмерном пространстве. В Unity для этого существуют методы. Прежде всего нужно разобраться с осями. Если вы возьмете телефон в руки и разместите его вертикально (портретная ориентация), то ось Y будет указывать вверх-вниз, ось X в стороны, а Z будет показывать глубину. Работа с акселерометром на самом деле более чем простая. За это отвечает Input.acceleration, который работает почти также как Input.GetAxis.

Рассмотрим пример. Заставим объект будет двигаться туда, куда наклонено устройство.

Бонус

Небольшой совет о том, как проверять работу приложений. Естественно проверить корректность работы своей системы управления можно только на устройстве. И что же, всё время билдить миллионы версий игры и проверять работу? По счастью, нет, не нужно. Команда Unity позаботилась о своих пользователях выпустив приложение Unity Remote.

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

Надеемся, эти советы помогут вам создать свою первую игру под сенсорные экраны и позволит проявить всю свою креативность.

Андроид-игры на UNITY3D

С каждым днём всё более популярным становится такое направление, как самостоятельная разработка компьютерных игр. Используя межплатформенную среду разработки компьютерных игр Unity 3d, можно создавать онлайн уникальные игры интересующего жанра для платформ Android, Windows, iOS, Blackberry, Wii, Xbox, Playstation. Широкое признание Unity3d завоевал среди желающих создать игру для «Андроид» самостоятельно. Этот конструктор имеет игровой движок, максимально реализующий возможности OpenGL и DirectX, а также содержит редакторы 3D-моделей и другие полезные программы для настройки звуков, ландшафтов, шейдеров и прочих компонентов.

Единственная сложность, с которой может столкнуться малоопытный в программировании пользователь – это необходимость написания программного кода. Но это не проблема, поскольку UNITY3DSCHOOL научит, как быстро и просто справиться с этой задачей. Особенно если вы горите идеей создать игру для «Андроид» и стать автором уникального программного продукта. Авторские методики обучения разработке игр позволят превратить компьютерное хобби в прибыльное занятие, приносящее хороший дополнительный доход.

А есть ли у вас план?

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

1. Концепция. Прежде всего необходимо детально проработать саму идею, тогда будет понятно, в каком направлении двигаться дальше.
2. Дизайн-проект или создание наброска. Это фактически техническое задание, план того, как создать игру для «Андроид» пошагово.
3. Изучение особенностей UNITY и её возможностей для понимания, насколько она сможет раскрыть потенциал будущей игры.
4. Моделирование игры онлайн в конструкторе. Пожалуй, самый увлекательный и творческий этап разработки игры. Здесь можно много экспериментировать, подбирая наиболее подходящие компоненты.
5. Когда концепция реализована, не лишним будет протестировать свой продукт и оценить все ли части дизайн-проекта реализованы.

Вперёд, к покорению виртуальных просторов!

Теперь можно подумать о том, чтобы запустить игру онлайн, например в Play Store.

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

Источник