Начало разработки под Android
Разработка игр для устройств с Android OS требует подхода, схожего с разработкой под iOS. С другой стороны, аппаратное обеспечение Android-устройств не подчиняется чётким стандартам, что заставляет решать вопросы, которые отсутствуют при работе с iOS. Также присутствуют различия между версиями Unity для Android и iOS.
Подготовка среды разработки для Android
Прежде чем вы сможете протестировать свои игры на устройстве, вам нужно будет подготовить среду разработки. В частности — скачать и установить Android SDK нужной платформы и добавить ваше устройство в систему (этот процесс отличается для Windows и Mac). Об этом подробно написано на сайте Android-разработчиков, а также дополнительную информацию может предоставлять производитель вашего устройства. Так как это достаточно сложный процесс, мы приготовили небольшую инструкцию которая поможет вам подготовить всё необходимое для разработки. Если вам понадобится больше информации, вы сможете получить её на портале Android-разработчиков.
Доступ к функциям Android
Unity предоставляет API для доступа к средствам ввода и настройкам Android. Доступные классы задокументированы на странице Написание кода для Android сборок.
Привязка C, C++ или Java кода к скриптам
Unity позволяет вызывать функции, написанные на C/C++, непосредственно из скриптов (Java-функции могут быть вызваны непрямым способом). Чтобы узнать как из Unity получать доступ к функциям из нативного кода, посетите страницу о сборке плагинов для Android.
Occlusion Culling (отсечение невидимой геометрии)
Unity предоставляет поддержку occlusion culling, что очень полезно при оптимизации для мобильных платформ. Больше информации можно найти на странице Occlusion culling.
Настройка начальной заставки
Заставка, отображаемая при запуске игры, может быть настроена — см. эту страницу для дополнительной информации.
Решение проблем и сообщения об ошибках
Существует множество причин, из-за которых ваше приложение вылетает или не работает должным образом. Наше руководство по решению специфических для Android проблем поможет вам разобраться с причинами ошибок в кратчайшие сроки. Если после прочтения руководства вы предполагаете, что проблема именно в Unity — вам следует составить сообщение об ошибке. Обратитесь к этой странице за инструкциями.
Как Unity для Android отличается от версии для настольных компьютеров
JavaScript со строгой типизацией
Для улучшения производительности в Android-версии Unity динамическая типизация в JavaScript всегда отключена (как если бы к каждому скрипту автоматически применялась #pragma strict). Это важно помнить, если вы переносите на Android проект со старших платформ, и если вы столкнётесь с ошибками компиляции — проблему стоит искать в первую очередь в типизации. С такими ошибками обычно легко справиться, убедившись что типы всех переменных явно указаны или приведёны при инициализации.
ETC — рекомендуемый способ сжатия текстур
Хоть Unity Android и поддерживает DXT/PVRTC/ATC текстуры, Unity распакует текстуры в формат RGB(A) при выполнении, если эти методы сжатия на поддерживаются на конкретном устройстве. Это может серьёзно повлиять на производительность GPU отрисовки, потому рекомендуется использовать формат ETC. Он является фактическим стандартом для Android, и должен поддерживаться всеми современными устройствами. С другой стороны, ETC не поддерживает альфа-канал, и иногда 16-битные RGBA текстуры будут лучшим выбором по критериям качества, размера и скорости рендеринга там, где нужен альфа-канал.
Также возможно создать несколько дистрибутивов игры (apk-файлов) с разными форматами текстур, чтобы Android Market сам предоставлял для каждого устройства наиболее подходящий из дистрибутивов. За подробностями обратитесь к этой странице.
Проигрывание видео.
Видео текстуры (MovieTexture) не поддерживаются на Android, но программно доступно полноэкранное поточное проигрывание. Для дополнительной информации о поддерживаемых форматах файлов и API скриптинга, ознакомьтесь со страницой класса MovieTexture или со страницей поддерживаемых на Android форматах медиа.
Разработка игр для Android
Создавайте качественные игры с Unity, ведущей платформой разработки, которой доверяют разработчики 75% игр на мобильном рынке Android.
72% из 1000 самых популярных мобильных игр были созданы на движке Unity
Более 50% всех мобильных игр разработаны на Unity
Unity работает в основе более 75% самых успешных игр Google Play
Охватите более 1 миллиарда игроков с помощью Unity Distribution Portal
Разработайте новую мобильную игру для Android
Воплощайте творческие замыслы
РАЗРАБОТКА
Unity Pro Создайте игру мечты и сделайте ее успешной.
Unity Asset Store Ускоряйте разработку игр благодаря инструментам, ассетам и шаблонам.
Plastic SCM Обеспечьте эффективную командную работу программистов и художников.
Multiplayer Размещайте и поддерживайте игровые серверы.
Game Backend (бета-версия) Храните данные игры в управляемой облачной инфраструктуре.
Подробная аналитика и быстрые исправления
ОПТИМИЗАЦИЯ
Backtrace Выявляйте, сортируйте и устраняйте ошибки с помощью кроссплатформенной системы управления ошибками и исключениями.
Unity Gaming Services Analytics Анализируйте показатели игры и поведение игроков.
Создавайте увлекательные игры
Cloud Content Delivery Управляйте ассетами и доставляйте контент через облако.
Helpshift Помогайте клиентам, используя первую для мобильных игр встроенную систему поддержки.
Развивайте успешный бизнес
МОНЕТИЗАЦИЯ
Unity Ads Увеличивайте доход и привлекайте новых пользователей, используя внутриигровую рекламу.
Встроенные покупки Упрощенная интеграция для различных магазинов приложений.
Издайте лучшую игру для Android на Chrome OS
Охватите больше игроков, перенося Android-игры на устройства Chromebook, самый быстрорастущий на сегодняшний день сегмент ПК, с помощью Google и Unity.
Истории успеха
Ludo King от Gametion
Узнайте, как студия Gametion, которая только недавно освоила Unity, с помощью простой и знакомой игровой концепции завоевала более 1 миллиона установок на мобильном рынке менее чем за 25 дней после выпуска на Google Play.
Chaos Lords от Digital Pill
Узнайте, как студия Digital Pill выпустила игру и охватила более 1 миллиарда игроков с помощью Unity Distribution Portal.
Last Day on Earth от Kefir
С помощью технологий и магазинов приложений студия Kefir добилась невероятных 83 миллионов загрузок, 1 миллион активных пользователей ежедневно (DAU), и более 125 млн $ валового дохода с игрой Last Day on Earth — и это не предел.
Ресурсы
Освойте Samsung Adaptive Performance
Наше партнерство с Samsung позволяет оптимизировать игры для самых популярных Android-устройств. Воспользуйтесь удобными инструментами для поддержания оптимальной производительности приложений на любых устройствах Samsung.
Оптимизировано для миллиардов мобильных устройств
Мы заключили партнерское соглашение с Arm, ведущим мировым производителем полупроводниковых устройств, для повышения производительности приложений на миллионах графических и центральных процессоров Arm.
Внедрите технологии AR в вашу мобильную игру
Unity AR Foundation упрощает разработку мультиплатформенных игр с дополненной реальностью. Наше партнерство с Google ARCore позволяет разработчикам игр для Android использовать новые функции ARCore в день их выхода.
Осваивайте возможности мобильной разработки
Узнайте о функциях Unity, которые созданы специально в помощь разработчикам впечатляющих, производительных мобильных игр.
От идеи до успешной реализации
Присоединяйтесь к миллионам разработчиков мобильных игр по всему миру, которые используют Unity для создания успешных игр нового поколения.
Социальная
Copyright © 2023 Unity Technologies
- Legal
- Privacy Policy
- Cookies
- Do Not Sell or Share My Personal Information
- Настройки файлов cookie
Unity, логотипы Unity и другие торговые знаки Unity являются зарегистрированными торговыми знаками компании Unity Technologies или ее партнеров в США и других странах (подробнее здесь). Остальные наименования и бренды являются торговыми знаками соответствующих владельцев.
Мы используем cookie-файлы, чтобы вам было удобнее работать с нашим веб-сайтом. Подробнее об этом можно узнать на странице, посвященной политике использования cookie-файлов.
Как быстро написать игру для Android на Unity
В своё время Flappy Bird, не имея сложной механики и графики, стала хитом. Сегодня мы расскажем, как всего за 10 минут написать свой вариант игры на Unity под Android.
В нынешнее время каждый может стать успешным разработчиком мобильных игр или приложений, не прилагая к этому титанических усилий. Примером такого случая является Донг Нгуен, разработавший Flappy Bird. В игре не было никакой сложной механики или графики, но это не помешало ей стать популярной и приносить своему создателю по пятьдесят тысяч долларов в день. Однако в игре не было ничего примечательного. Всё, что потребовалось для успеха, — оказаться в нужном месте в нужное время и немного удачи. Подобное может произойти и сегодня, вам просто нужна правильная идея.
Чтобы продемонстрировать, насколько легко написать что-то подобное, сегодня мы напишем свой Flappy Bird с помощью Unity всего за 10 минут.
Игровой персонаж
Сначала создайте новый проект и убедитесь, что выбрана опция 2D.
Загрузите свой спрайт птицы в сцену. Не забудьте включить фантазию!
Затем отрегулируйте размер спрайта как вам нравится, перетягивая его за угол в нужном направлении. Спрайт должен быть виден в окне иерархии ( hierarchy ) слева. В нём видны все объекты в сцене, и на данный момент их должно быть всего два: камера и птица.
Перетащите камеру на птицу и отпустите. Камера должна оказаться под птицей, это будет значить, что камера теперь «ребёнок» птицы. Теперь позиция камеры будет фиксироваться относительно птицы. Если птица двигается вперёд, то камера делает то же самое.
Снова выберите птицу в сцене или в окне иерархии. Вы увидите список опций и атрибутов справа в окне под названием Inspector . Здесь вы можете управлять различными переменными, привязанными к определённому объекту.
Теперь нажмите на Add Component . Выберите Physics2D > Rigidbody2D — это готовый набор инструкций для применения гравитации к нашему персонажу. Нажмите на Constraints в этой панели и затем выберите freeze rotation Z . Это позволит предотвратить вращение птицы вместе с камерой по кругу.
Таким же образом добавьте Polygon Collider , который говорит Unity, где находятся границы персонажа. Нажмите Play и увидите, как спрайт вместе с камерой бесконечно падает вниз.
Пока всё идёт хорошо!
Теперь пора заняться полётами персонажа, благо это будет несложно.
Сначала нужно создать C#-скрипт. Создайте для него папку (кликните правой кнопкой мыши где-нибудь в assets и создайте папку «Scripts»), сделайте клик правой кнопкой мыши и выберите Create > C# Script .
Назовём его «Character». Кликните по нему дважды, чтобы открыть его в вашей IDE, будь то MonoDevelop или Visual Studio. Затем добавьте следующий код:
public class Character : MonoBehaviour < public Rigidbody2D rb; public float moveSpeed; public float flapHeight; // Это нужно для инициализации void Start () < rb = GetComponent(); >// Update вызывается один раз на кадр void Update () < rb.velocity = new Vector2(moveSpeed, rb.velocity.y); if (Input.GetMouseButtonDown(0)) < rb.velocity = new Vector2(rb.velocity.x, flapHeight); >if (transform.position.y > 18 || transform.position.y < -19) < Death(); >> public void Death() < rb.velocity = Vector3.zero; transform.position = new Vector2(0, 0); >> Этот код делает две вещи. Он заставляет персонажа двигаться вперёд со скоростью, которую мы определим в инспекторе, и создаёт ощущение полёта птицы. Метод Update() вызывается повторно на протяжении игры, поэтому всё, что вы сюда поместите, будет выполняться непрерывно. В данном случае мы добавляем немного скорости нашему объекту. Переменная rb является скриптом RigidBody2D , который мы применили к нашему объекту ранее, поэтому когда мы пишем rb.velocity , мы обращаемся к скорости объекта.
Тап по экрану интерпретируется Unity как клик мыши, если вы используете мобильное устройство. После нажатия мы заставляем персонажа немного подняться вверх.
Переменная moveSpeed будет отвечать за скорость движения, а переменная flapHeight — за увеличение высоты полёта птицы после каждого нажатия. Поскольку эти переменные объявлены как public , мы сможем изменить их вне скрипта.
Метод Death() тоже объявлен как public , что значит, что другие объекты и скрипты смогут его вызвать. Этот метод просто возвращает положение персонажа в начало. Также он будет использоваться каждый раз, когда персонаж будет залетать слишком высоко или низко. Скоро вы поймёте, почему он объявлен именно как public . Строка rb.velocity = Vector3.zero; нужна, чтобы убрать импульс — мы же не хотим, чтобы после каждой смерти персонаж падал всё быстрее и быстрее?
Теперь можно выходить из IDE и добавлять скрипт как компонент к персонажу. Для этого нужно выбрать нашу птицу и нажать Add Component > Scripts > Character . Теперь мы можем определять moveSpeed и flapHeight в инспекторе (для этого и нужны public -переменные). Присвоим переменным значения 3 и 5 соответственно.
И ещё: в инспекторе нужно добавить тег к персонажу. Для этого кликните там, где написано Tag: Untagged и затем выберите Player в выпадающем списке.
Препятствия
Теперь добавим препятствия: трубы. Кто-то в трубах находит грибы, а кто-то — свою смерть.
Перетащите спрайт трубы в сцену в место, где должно быть первое препятствие, и назовите его pipe_up .
Теперь создадим новый скрипт под названием Pipe :
public class Pipe : MonoBehaviour < private Character character; // Это нужно для инициализации void Start () < character = FindObjectOfType(); >// Update вызывается один раз на кадр void Update () < if (character.transform.position.x - transform.position.x >30) < >> void OnCollisionEnter2D(Collision2D other) < if (other.gameObject.tag == "Player") < character.Death(); >> > Добавьте этот скрипт к спрайту трубы тем же образом, что и раньше. Таким образом, труба будет возвращаться на экран после выхода за его левую границу. Мы тут ещё ничего не сделали, но ещё вернёмся к этому.
Метод OnCollisionEnter2D() вызывается каждый раз при взаимодействии трубы с персонажем. После этого вызывается созданный ранее метод Death() , возвращающий игрока в начальную точку.
Итак, у нас есть одна труба, которая время от времени будет исчезать и появляться на другом конце экрана. Врежешься в неё — умрёшь.
Перевёрнутые трубы
Сейчас у нас есть только один спрайт трубы. Давайте добавим ещё один. Для этого кликните правой кнопкой мыши в окне иерархии, нажмите New 2D Object > Sprite и затем выберите спрайт, который хотите использовать. Ещё проще будет просто перетащить файл в сцену ещё раз.
Назовите этот спрайт pipe_down . В инспекторе в части Sprite Renderer выберите опцию Flip Y , чтобы перевернуть трубу вверх ногами. Добавьте такое же RigidBody2D .
Теперь напишем новый C#-скрипт под названием PipeD . В нём будет похожий код:
public class PipeD : MonoBehaviour < private Character character; //Это нужно для инициализации void Start() < character = FindObjectOfType(); >// Update вызывается один раз на кадр void Update() < if (character.transform.position.x - transform.position.x >30) < >> void OnCollisionEnter2D(Collision2D other) < if (other.gameObject.tag == "Player") < character.Death(); >> > Префабы
Итак, нам достаточно этого кода, чтобы сделать всю игру. Мы могли бы передвигать трубы на правую сторону экрана каждый раз, когда они исчезают, или скопировать и вставить столько труб, сколько мы хотели бы встретить на протяжении всей игры.
Если пойти первым путём, то убедиться, что трубы стоят как надо после случайной генерации, и поддерживать честный ход вещей было бы сложно. После смерти персонажа они могли бы появиться в километрах от первой трубы!
Если пойти вторым путём, то всё закончится излишним потреблением памяти, с вытекающим из этого замедлением игры, и ограниченной реиграбельностью, т.к. всё стоит на одних и тех же местах каждый раз.
Вместо этого давайте воспользуемся префабами. Если говорить просто, то мы превратим наши трубы в шаблоны, которые потом сможем использовать для эффективного создания большего количества труб по желанию. Если тут есть программисты, то считайте скрипт Pipe классом, а трубы — экземплярами этого объекта.
Для этого создайте новую папку «Prefabs». Затем перетащите pipe_up и pipe_down из окна иерархии в папку.
Каждый раз, когда вы перетаскиваете объект из этой папки в сцену, у него будут те же свойства, поэтому вам не нужно будет постоянно добавлять компоненты. Более того, если вы измените размер компонента в папке, это повлияет на все трубы в игре, и вам не придётся изменять каждую из них отдельно.
Как вы понимаете, это сильно сэкономит наши ресурсы. Также это означает, что мы можем взаимодействовать с объектами из кода. Мы можем создавать экземпляры наших труб.
Сначала добавьте этот код в условное выражение в методе Update() скрипта Pipe , которое мы оставили пустым:
void Update () < if (character.transform.position.x - transform.position.x >30) < float xRan = Random.Range(0, 10); float yRan = Random.Range(-5, 5); Instantiate(gameObject, new Vector2(character.transform.position.x + 15 + xRan, -10 + yRan), transform.rotation); Destroy(gameObject); >> Это нужно для создания экземпляра нашего gameObject . В результате получается новая идентичная копия. В Unity всегда, когда вы используете слово gameObject , оно ссылается на объект, к которому скрипт в данный момент привязан — в нашем случае к трубе.
Мы генерируем заново наши трубы в случайных вариациях, чтобы было повеселее.
Но вместо того, чтобы проделывать всё то же в скрипте PipeD , мы генерируем оба объекта в одном месте. Таким образом мы можем легко устанавливать положение второй трубы относительно первой. Также это значит, что нам нужно меньше кода для PipeD .
Создайте public gameObject с именем pipeDown . Затем обновите код следующим образом:
if (character.transform.position.x - transform.position.x > 30)
Мы добавили переменную gapRan , которая позволяет слегка менять расстояние между трубами, чтобы было интереснее играть.
Возвращаемся обратно в Unity и перетаскиваем префаб pipe_down из папки с префабами (это важно!) в место, где написано «Pipe Down» (заметьте, как наш camel case заменяется пробелом) на спрайт трубы pipe up . Если вы помните, мы определили Pipe Down как public gameObject , что даёт нам возможность определять, чем является этот объект откуда угодно – в данном случае через инспектор. Выбирая префаб для этого объекта, мы убеждаемся, что при создании экземпляра трубы он будет включать в себя все атрибуты и скрипт, которые мы добавили ранее. Мы не просто создаём спрайт, но пересоздаём объект с коллайдером, который может убить персонажа.
Всё, что мы добавим в то же место в скрипте PipeD — просто Destroy(gameObject) , чтобы труба саморазрушалась при выходе за левую границу экрана.
Если вы сейчас запустите игру, то экран будет продвигаться дальше автоматически, и вы умрёте, если столкнётесь с любой из труб. Пролетите достаточно далеко, и эти трубы исчезнут и появятся снова впереди.
К сожалению, между трубами большое расстояние, и экран выглядит пустым. Мы могли бы исправить это, добавив несколько префабов в нашу сцену, чтобы создать конвейер постоянно появляющихся труб. Однако было бы лучше генерировать трубы в скрипте. Это важно, так как в противном случае после смерти персонажа трубы в начале пути уничтожатся, и снова образуется пустое пространство.
Таким образом, мы можем создавать несколько первых труб во время каждой загрузки игры и возвращать всё на свои места после смерти персонажа.
Бесконечный полёт
Теперь создадим public -переменные pipe_up и pipe_down в скрипте Character . Это даст вам возможность ссылаться на созданные объекты, перетаскивая префабы на объект персонажа, прямо как когда мы добавили pipe_down в скрипт Pipe .
Нам нужно добавить эти переменные:
public GameObject pipe_up; public GameObject pipe_down; Затем мы напишем такой метод:
public void BuildLevel()
Мы будем вызывать его один раз в методе Update() и один раз в методе Death() .
После начала игры вызывается Update() , и наши трубы ставятся согласно заданной конфигурации. За счёт этого первые несколько препятствий всегда будут стоять на одном и том же месте. После смерти игрока трубы встанут на те же самые места.
Вернитесь в сцену в Unity и удалите две трубы, которые сейчас там находятся. Ваша «игра» будет выглядеть просто как пустой экран с птицей. Нажмите Play и трубы появятся, после нескольких первых их положение будет определяться случайным образом.
В заключение
Вот мы и сделали целую игру! Добавьте счётчик очков, попробуйте сделать его более оригинальным и увеличивайте сложность игры по мере продвижения. Также не будет лишним сделать меню. Ещё хорошей идеей будет уничтожать трубы на экране после смерти персонажа. Как только вы с этим закончите — считайте, что готовая к выпуску в Play Store игра у вас в кармане! Когда-то похожая игра сделала другого разработчика очень богатым, и это доказывает, что вам не нужно быть гением-программистом или иметь за своей спиной богатого издателя, чтобы достичь успеха. Вам просто нужна хорошая идея и десять минут!
Хотите писать приложения под Android, но не знаете, с чего начать? Тогда ознакомьтесь с нашей большой подборкой ресурсов для изучения Android-разработки.
Управление в 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. Написание кода таким образом делает его максимально безопасным и читаемым.
Алгоритм состоит из следующий частей:
- Зарегистрировать хотя бы одно касание
- Сохранить интересующий нас элемент массива
- Получить фазу касания экрана и что-то сделать.
И не забываем про директивы и платформенно зависимую компиляцию. Это первое что мы сделаем в коде.
Внутри этой директивы мы имеем право описать управление. Первое – удостовериться,что касание произошло. Input записывает количество касаний в Input.touchCount.
Второе – получить первое в списке касание.Существует объект Touch, который содержит всю информацию об единичном касании. Чтобы получить нужную информацию используем метод Input.GetTouch(). Этот метод принимает как аргумент любое целое число – оно и будет показывать индекс искомого элемента в массиве. Про массивы и то как с ними работать можно найти в любом учебнике по с#. Внутри предыдущего условия пишем: 
Отлично, мы получили информацию о касании и сохранили её в переменную. Что мы можем извлечь из этого.
Любые сенсорные экраны могут регистрировать разные данные: фаза касания (начало, движение, окончание), позицию на экране и количество быстрых касаний, а также информацию о поведении (траектория движения и подобное). В примерах будет использоваться имя переменной, которую мы создали в предыдущем этапе, а именно myTouchтипа Touch.
Естественно имя переменной вы можете задавать сами.
- Фаза касания: их существует несколько. Найти их можно в свойстве myTouch.phase объекта Touch. Представляют собой перечисление TouchPhase. Варианты такие:
- Began – произошло начало касания
- Moved – пользователь водит пальцем по экрану
- Stationary – пользователь касается экрана, но не меняет положения касания
- Ended – касание прекратилось
- Canceled – система не может считать касание(например пользователь касается ладонью и невозможно определить количество контактов)
Пример 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 рекомендует придерживаться следующего незамысловатого плана действий.
- Концепция. Прежде всего необходимо детально проработать саму идею, тогда будет понятно, в каком направлении двигаться дальше.
- Дизайн-проект или создание наброска. Это фактически техническое задание, план того, как создать игру для «Андроид» пошагово.
- Изучение особенностей UNITY и её возможностей для понимания, насколько она сможет раскрыть потенциал будущей игры.
- Моделирование игры онлайн в конструкторе. Пожалуй, самый увлекательный и творческий этап разработки игры. Здесь можно много экспериментировать, подбирая наиболее подходящие компоненты.
- Когда концепция реализована, не лишним будет протестировать свой продукт и оценить все ли части дизайн-проекта реализованы.
Вперёд, к покорению виртуальных просторов!
Теперь можно подумать о том, чтобы запустить игру онлайн, например в Play Store.
Разработка компьютерных игр — увлекательное занятие. Наши курсы помогут вам реализовать вашу идею в максимально короткий срок.