2d games план урока

Обновлено: 04.07.2024

Недавно команда Whistling Kite Framework выпустила в релиз очередную игру, на этот раз — Змейку, написанную на Unity3D. Как и в большинстве игровых проектов, при решении вопроса о том, насколько детально нужно проектировать приложение, критическим фактором было время. В нашем случае причина проста: т.к. разработка велась в свободное от основной работы время, то идеальный подход к проектированию отложил бы релиз ещё на год. Поэтому, составив первоначальное разделение на модули, мы закончили проектирование и приступили к разработке. Под катом описание того, что из этого получилось, а также пара уроков, которые я вынес для себя.

Осторожно, картинки!

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

Функциональность

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

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

4 кнопки — задать новое направление движения;
2 кнопки — поворот налево/направо от текущего направления;
свайпы — провести пальцем в нужном направлении.

Планируем добавить еще два:

гироскоп — наклон устройства задает новое направление;
джойстик-”пузырь” — смещение пальца от первой точки касания задает новое направление.

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

Решение о старте разработки змейки мы принимали, преследуя две цели:

Архитектура

Этап 1. Концепция

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

Исторически последним был выделен слой инициализации, хотя в приложении он должен был запускаться первым. Дело в том, что мы сначала заложили инициализацию объектов в сами объекты, но потом решили выделить ее централизованно.
Слои интерфейса, логики и контроллеров представляют собой почти классической паттерн MVC. При этом было желание разделить обработку этих слоёв даже на разные потоки, чтобы обеспечить максимальную плавность интерфейса.
Слой управления был вынесен отдельно, т.к. мы решили, что разнообразные варианты управления будут одной из наших основных фич, поэтому нужно было делать так, чтобы всё остальное приложение не зависело от выбранного варианта.
Все слои должны были общаться между собой посредством выделенных интерфейсов, каждый слой содержал свои объекты и выполнял свои функции, зачастую содержал свой поток обработки.

Раздельные слои контроллеров и управления: впоследствии от контроллеров в терминах MVC отказались в силу избыточности.
Слишком высокоуровневое описание: непонятно, какой писать код. Хотя это и нельзя назвать чистым промахом, т.к. на момент создания этой архитектуры не был выбран ещё движок.

Следующим этапом стал выбор платформы, хотя, строго говоря, выбор делался между unity и разработкой на чистой java. Беглый обзор других существующих движков не вызвал энтузиазма в их изучении. Мы пришли к достаточно ожидаемому выводу: написать змейку проще вообще без платформы, к тому же это выглядело интереснее — кто ж не любит делать свои велосипеды? Однако, мы выбрали unity, с целью ознакомления с платформой, близкой к статусу стандарта де-факто в области гейм-дева. Да, мы получили солидный оверхед из-за того, что unity — трёхмерный движок (на момент начала разработки у unity еще не было нативной поддержки 2D), а делали мы двумерную игру, но полученный опыт того стоил.

Этап 2. Проект

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

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

Сущность-связь (понятно, что это скорее относится к разряду требований к системе, чем к её архитектуре, но в контексте статьи я не могу её не упомянуть:

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

Диаграммы компонентов и кооперации. Для их восприятия предварительно опишу ряд договоренностей:

Компоненты системы (прямоугольники);
Подсистема хранения (символ БД, магнитного диска);
Примечания (желтые “листки”);
Потоки управления (закрашенные стрелки);
Потоки данных (пунктирные стрелки).

Компоненты, объекты (прямоугольники);
События, обрабатываемые объектами (шестиугольники);
Действия, выполняемые по событиям (эллипсы).

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

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

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

Отдельно выделены компоненты для логирования и расшаривания рекордов.

Игровой мир состоит из объектов, взятых с ERD. Ключевую роль играют партия и змейка.

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

Выделение двух основных независимых подсистем: при разработке это не было учтено, что первоначально привело к большому количеству лишних сцен.

Не учитывает разделение по сценам и работу с подсистемой хранения из игровой сцены
Не отвечает на вопрос, как реализовывать подсистему GUI и как подсистемы взаимодействуют между собой.
Объект Партия взял на себя функции контроллера в терминах MVC.

Этап 3. Фактический результат

После старта разработки архитектуру уже никто не корректировал. Я только оставлял отдельные заметки в соответствующем разделе дизайн-документа о том, как реализованы те или иные узкие места, но основная цель была выпустить релиз. Что ж, этой цели мы достигли, и я сел за рефакторинг, чтобы подготовиться к разработке второго релиза. Уже на тот момент я понимал, что в первую очередь надо переводить игру на честный 2d, поддержка которого как раз появилась в unity. И ещё было понимание, что полученный результат далёк от идеального, в первую очередь в части разделения функций по объектам и их взаимодействию, поэтому, я поставил себе две задачи:

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

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

Обзор созданных классов

На диаграмме ниже представлены все классы, созданные при разработке игры. На диаграмме скрыта часть методов, не несущих смысловой нагрузки или настолько тривиальных, что не стоят упоминания. Также часто под именем переменной (например, textures) скрывается целый блок переменных (в данном случае — разнообразных текстур).

Gamelogic — здесь представлены классы для игровых объектов, существующих на ирговом поле. По сути, этот паявляется ядром игры.
Gui — здесь представлены классы, отвечающие за построение статического пользовательского интерфейса: главное меню, настройки, рекорды и кнопки поверх игрового поля, кроме кнопок непосредственного управления змейкой.
Controllers — это изюминка нашего приложения: пакет с разнообразными способами управления змейкой. Каждый класс полностью содержит в себе все необходимое для выбранного стиля управления: от интерфейсных кнопок до логики расчета поворота.
Providers — этот пакет содержит вспомогательные классы, обеспечивающие такие функции, как чтение и сохранение данных, возможности поделиться рекордом, логирование, аналитику и т.п.

Второй по важности класс Snake содержит логику движения змеи, включая управление зависимыми объектами класса Snakechain. Именно этому классу передают команды контроллеры управления.

Для создания экземпляров фруктов (FruitInstance) используется фабрика, т.к. в будущем планируется увеличивать количество разных типов фруктов.

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

Пакет с контроллерами содержит управляющие классы. Они добавляются к змейке и взаимодействуют напрямую с объектом Snake, используя паттерн command, а змейка выполняет поступившие команды в той же последовательности, но раздельно по своим шагам. Это было сделано для корректной обработки быстрых последовательных команд, например для разворота на 180 градусов вдоль своего хвоста.

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

Начальные состояния

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

Главное меню создается двумя классами, Player и GUInavigator, присоединенными к единственному объекту на сцене, к камере. Player отвечает за загрузку всей основной информации об игроке, а GUInavigator инициирует нужное поведение из пакета интерфейсов и обеспечивает дальнейшие переходы между интерфейсами.

Игровая сцена содержит гораздо больше объектов. Большинство из них статические, представляющие собой мир змейки: фон, игровое поле, стены. Дополнительные поведения прикрепляются только к двумя объектам: к камере (GUInavigator, Player, party, fruitfabric) и голове змейки (Snake, Controllerselector). Controllerselector отвечает за выбор управляющего контроллера в соответствии с настройками игрока.

Запуск приложения

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

Загрузка приложения состоит из обработки двух событий: awake и start. Событие awake обрабатывает объект player: в этот момент он обращается к DataProvider-у для загрузки информации об игроке, а потом вызывает собственный метод, отвечающий за применение текущих настроек, например, отключение звука.

GUInavigator в методе initMain инициирует все необходимые в данной сцене интерфейсы, каждому проставляя признак неактивности.
Далее он проверяет, не было ли сохранено незавершенной игры. Это возможно, например, при прерывании игры входящим звонком.
1. Если игра есть, то происходит загрузка игровой сцены, а данный сценарий прерывается.
Запуск игры

Далее рассмотрим диаграмму последовательности, иллюстрирующую действия при запуске игры. Точка начала — загрузка сцены с игрой.
На данной диаграмме стоит отдельно отметить альтернативный сценарий загрузки сохраненной игры — это нужно для случая прерывания игры, например, входящим звонком.
1. Controller selector в событии Start, проверяет настройки игрока и подгружает нужный контроллер управления.
2. GUInavigator в методе initGame инициирует все необходимые в данной сцене интерфейсы, каждому проставляя признак неактивности. Определение, какой метод вызвать, прроисходит на основе параметра, заданного через редактор. Инициализация и включение активного интерфейса происходят аналогично запуску приложения.
3. Далее событие Start обрабатывает объект party. Первым делом он проверяет, нет ли сохраненной игры.
  1. Если игра есть, то party вызывает dataProvider для восстановления, который, прочитав данные вызывает метод Restorebackup объекта party.
  2. Он, в свою очередь вызывает аналогичный метод объекта Snake, а тот по цепочке для всех звеньев.
  3. После восстановления данных, управление возвращается объекту party, он включает паузу и ждет действий игрока.
  Игровой цикл: движение змеи
  
  Игровая логика сосредоточена вокруг обработки двух событий: update обрабатывается в змейке методом movehead, здесь происходит движение змеи и управление движением ее сегментов; и ontriggerenter, где происходит обработка столкновений головы змеи с фруктами, стенами и собственным хвостом.
  1. При возникновении события сначала проверяется, с кем мы столкнулись: если это яблоко, то вызывается метод Eatfruit, а если хвост или стена, то Killme. В обоих случаях информация о столкновении сбрасывается в логи.
  2. Случай яблока:
    1. Змейка выставляет флаг необходимости добавления звена и вызывает метод Eatfruit объекта party.
    2. Party увеличивает рейтинг партии и вызывает свой же метод createfruit, использованный также при запуске игры.
    3. В этом методе сначала удаляется текущий экземпляр фрукта, а затем создается новый через обращение к фабрике.
    1. Змейка передает обработку события объекту party в метод Endgame.
    2. Party выставляет режим паузы и, через навигатор интерфейса, переводит игрока на экран с результатами партии.
    1. В событии update вызывается метод movehead
    2. Здесь проверяется скорость змейки: наступил момент перехода или нет
    3. Если да, то проверяется флаг необходимости добавления звена
      1. Если нужно, то создается звено, аналогичное следующему за головой
      2. Смещаются только голова и одно вновь созданное звено.
      Заключение
      
      За рамки данной статьи осталось достаточно много логики: это логирование, как внутреннее, так и с использованием внешних средств аналитики; это работа навигатора интерфейсов, который инкапсулирует все особенности, связанные с двумя сценами; это работа с данными, с устройством, показ рекламы и еще много других особенностей. Если кому-то будет интересно, я могу написать об этом отдельно.
      
      Недавно мы рассказали о том, как научиться разработке игр на Unity . Продолжим тему на практике и покажем, как новичку создать на этой платформе первую 2D-игру.
      
      Если вы хотите получить более систематическое образование в области разработки игр, мы рекомендуем рассмотреть факультет разработки игр онлайн-университета GeekBrains.
      
      Двумерные игры сравнительно просты: для них не требуется сложных 3D-моделей, программный код по сравнению с 3D-проектами выглядит понятнее. Такие игры популярны как на десктопах, так и на мобильных устройствах. Unity также позволяет разрабатывать игры и для браузеров.
      
      За последние годы вышло много популярных двумерных игр:
      
      Программная реализация 2D-игр проще не только из-за отсутствия третьего измерения: на самой сцене меньше объектов, вместо трехмерных моделей плоские спрайты, вместо скелетной анимации – покадровая. А еще 2D-игры проще портировать на другие платформы – легче найти новую аудиторию.
      
      Давайте создадим простую игру в жанре пинг-понг 🏓 . Перед тем как приступить к созданию игры, продумайте, какой именно результат хотите получить. На первых этапах рекомендуется использовать схематические шаблоны, чтобы быстрее получить работающий результат. В этой инструкции мы так и поступим. Графических ресурсов использовать не будем: и ракетки, и отбиваемый мяч будем пока отображать простыми белыми спрайтами.
      
      Предварительно рассмотрим основные понятия Unity, без понимания которых будет проблематично создать игру:
      
      Предполагаем, что вы уже установили редактор и создали аккаунт на портале Unity.
      
      В первую очередь создадим новый проект и откроем его настройки (Edit → Project Settings). Во вкладке Editor установим параметр Default Behaviour Mode в значение 2D
      
      Настройка проекта Детальная настройка проекта
      
      Следующим шагом сохраним текущую активную сцену, назвав ее, например, Scene1. Теперь создадим основные игровые объекты: ракетку, мяч и менеджер игры, в котором будет храниться основная логика игры.
      
      1. Создаем пустой объект, переименовываем в GameManager.
      
      Создаем пустой объект
      
      3. Создаем квадратный спрайт, называем его Pad (Assets → Create → Sprites → Square). Аналогично создаем круглый спрайт Ball (Assets → Create → Sprites → Circle). Масштабируем спрайт Pad со следующими параметрами – x:0.5, y:2.5, z:1.
      
      Создаем спрайты
      
      4. Создаем префабы для Pad и Ball, после чего добавляем к ним компонент Box Collider 2D (включаем параметр Is Trigger) и компонент Rigidbody 2D (выставляем параметр Body Type в значение Kinematic).
      
      Добавляем .компонент Box Collider 2D Настраиваем.компонент Box Collider 2D Добавляем компонент Rigidbody 2D Масштабируем спрайты
      
      6. Заполняем скрипты следующим кодом.
      
      GameManager.cs Ball.cs Pad.cs
      
      6. Добавляем к префабу Ball и Pad теги с аналогичными именами. Выделив префабы, в инспекторе мы можем видеть выпадающий список тегов. Там же расположены и кнопки для добавления и редактирования тегов.
      
      7. В настройках камеры выставляем параметр Projection в значение Orthographic, а параметр Clear Flag – в значение Solid Color.
      
      Настройка камеры
      
      8. Настраиваем кнопки, как показано на следующих скриншотах (Edit → Project Settings → Input Manager).
      
      Настройка ввода, основное Настройка ввода, первый игрок Настройка ввода, второй игрок
      
      Вот и всё, игра готова!
      
      Пинг-понг, итоговый результат
      
      Билд для платформы Windows
      
      1. Официальный туториал от Unity, где детально рассмотрен процесс создания roguelike RPG.
      
      2. Youtube-канал Brackeys , где можно найти серию видеоуроков по созданию 2D-платформера.
      
      3. Youtube-канал N3K EN содержит множество уроков как по отдельным компонентам Unity, так и полноценные серии уроков по созданию игр с нуля.
      
      Если у вас мало опыта в разработке игр на Unity, мы рекомендуем обратить внимание на факультет разработки игр GeekBrains . Материал хорошо структурирован и содержит все необходимое для того, чтобы стать профессиональным Unity-разработчиком.
      
      В числе прочего вы разработаете 2D-платформер с физическими загадками и динамическим освещением, научитесь портировать его на мобильные устройства. Кроме того, разработаете полноценную браузерную стратегию, а также игру в жанре двухмерных гонок.
      
      По окончании обучения вы будете иметь портфолио из 4 игр, которое можно показать на собеседовании. Если же какая-то часть материала будет непонятна, вы всегда можете обратиться к персональному преподавателю.
      
      Начнем с самого простого: загрузки и настройки Unity.
      
      Загрузите последнюю версию с официального сайта или торрента и запустите установочный файл.
      
      Полезно знать: невозможно использовать отладчик Visual Studio 2013 Express с Unity. Вы должны иметь Pro версию Visual Studio и купить UnityVS плагин. С версией Express, вы будете иметь лучший редактор кода, но отсутствие отладчика сведет на нет все его достоинства.
      
      Mac OS X
      
      MonoDevelop 4 - существенно лучше, чем старый MonoDevelop 2 в предыдущих версиях Unity. Он, конечно, далек от совершенства, но ничего лучшего под на Mac не придумано.
      
      На каком языке программировать в Unity?
      
      Научиться пользоваться в главным интерфейсом Unity достаточно просто. Вам, может быть, будет страшно в первый раз, когда открываете программу, но уже через несколько часов вы будете чувствовать себя в нем как рыба в воде.
      
      Вот несколько ссылок, которые могут быть вам полезными:
      - Изучение интерфейса Unitys : основа всех основ. Не зная интерфейса, вы не сможете создавать игры в Unity 3D
      - Создание сцены в Unity : изучение этого раздела поможет вам создать свою собственную сцену
      Первая сцена. Создаем новый проект.
      
      Выберите меню File , а затем создаqnt новый проект. Не выбирайте нивакой стандартный пакет на первое время. Вы можете повторно импортировать их позже, если вы захотите, просто поначалу они будут просто сбивать вас с толку.
      
      Выберите 2D настройки. Как и прежде, вы можете изменить этот флаг в настройках проекта позже.
      
      Не беспокойтесь о названии. Оно определяется в настройках, и чтобы изменить имя проекта достаточно просто переименовать папку.
      
      Разметка и панели Unity
      
      Перед вами пустая страница. С ней вы и будете работать, но вам потребуется время, чтобы настроить интерфейс в соответствии со своими конкретными нуждами. Лично мне удобнее, когда консоль находится рядом с игровым экраном, но если у вас маленький монитор, вы можете заменить панели вкладками.
      
      Прежде чем перейти к созданию игры, уделите несколько минут, чтобы подготовить свой проект и сцены.
      
      Чтобы держать все под рукой, советуем создать папки во вкладке Project (Проект). Эти папки будут созданы в папке Assets вашего проекта.
      
      Внимание: папка Assets – это место, где хранится все, что вы добавляете во вкладке Project. Она может быть невидимой в Unity, в зависимости от выбранной разметки вкладки (одна или две колонки), но вы сможете увидеть ее, открыв приложение для экспорта файлов.
      
      Вот пример структуры, которую мы используем в наших проектах. Вы можете адаптировать ее под свои предпочтения.
      
      Ассеты проекта
      
      В вашей панели Project, вы можете найти различные типы ассетов:
      
      Префабы
      
      Многоразовые игровые объекты (например: пули, враги, бонусы).
      
      Префабы можно рассматривать как класс в языке программирования, который может быть обработан в игровых объектах. Это некая форма, которую можно дублировать и изменить по своему желанию в сцене или во время выполнения игры.
      
      Сцены
      
      Сцена содержит игровой уровень или меню.
      
      В отличие от других объектов, создаваемых в панели "Проект", сцены создаются в меню "Файл". Если вы хотите создать сцену, нажмите на кнопку "Новая сцена" в подменю и не забудьте потом сохранить ее в папку Scenes.
      
      Сцены должны быть сохранены вручную. Это классическая ошибка в Unity - сделать некоторые изменения в сцене и ее элементы и забыть сохранить их после. Ваш инструмент контроля версий не увидите никаких изменений до тех пор, сцена не сохранится.
      
      Звуки
      
      Тут все предельно просто. Увидите, если захотите раскидать музыку по разным папкам.
      
      Scripts
      
      Textures
      
      Спрайты и изображения вашей игры. В 2D проекте вы можете переименовать эту папку в "Sprites".
      
      Это неважно для 2D проекта, но, оставив название Textures (Текстуры), вы дадите возможность Unity автоматизировать некоторые задачи. Если вы хотите узнать подробную информацию по этой теме, вы можете прочитать об этом здесь , или здесь .
      
      Заметка о папке Resources : если вы уже работали с Unity, вы знает, что Resources – полезная и уникальная папка. Она позволяет загрузить в скрипт объект или файл (с помощью статичного класса Resources ). Она понадобится нам в самом конце (в главе, посвященной меню). Проще говоря, пока мы не будем ее добавлять.
      
      Наша первая игровая сцена
      
      Панель Hierarchy (Иерархия) содержит все объекты, которые доступны в сцене. Это то, чем вы манипулируете, когда начинаете игру с помощью кнопки "Play".
      
      Каждый объект сцены является игровым объектом для Unity. Вы можете создать объект в главной сцене, или в другом объекте игры. Также вы можете в любое время переместить объект чтобы изменить его родителя.
      
      Как вы можете видеть здесь, у нас здесь 3 потомка для объекта Level .
      
      Пустые объекты
      
      В Unity можно создать пустой объект и использовать его в качестве "папки" для других игровых объектов. Это упростит структуру вашей сцены.
      
      Убедитесь, что все они имеют координаты (0, 0, 0) и тогда вы сможете легко их найти! Пустые объекты никак не используют свои координаты, но они влияют на относительные координаты их потомков. Мы не будем говорить об этой теме в этом уроке, давайте просто обнулим координаты ныших пустых объектов.
      
      Заполнение сцены
      
      По умолчанию, новая сцена создается с объектом Main Camera (Главная камера). Перетащите ее на сцену.
      
      Для начала создайте эти пустые объекты:
      
      Scripts Мы добавим наши скрипты сюда. Мы используем этот объект, чтобы прикрепить сценарии, которые не связаны с объектом – например, скрипт гейм-менеджера. Render Здесь будет наша камера и источники света. Level
      
      В Level создайте 3 пустых объекта:
      - 0 - Background
      - 1 - Middleground
      - 2 - Foreground
      Сохраните сцену в папке Scenes . Назовите ее как угодно, например Stage1 . Вот, что у нас получилось:
      
      Совет: по умолчанию игровой объект привязан к положению родителя. Это приводит к интересному побочному эффекту при использовании объекта камеры: если камера является дочерним объектом, она автоматически будет отслеживать положение родителя. Если же она является корневым объектом сцены или находится внутри пустого игрового объекта, она всегда показывает один и тот же вид. Однако если вы поместите камеру в движущийся игровой объект, она будет следовать за его передвижениями в пределах сцены. В данном случае нам нужна фиксированная камера, поэтому мы помещаем ее в пустой объект Render . Но запомните это свойство объекта камеры, оно может вам пригодиться. Мы подробно остановимся на этой теме в главе "Паралаксный скроллинг".
      
      Мы только что создали базовую структуру нашей игры. На следующем этапе мы начнем делать забавные вещи: добавим на сцену фон и кое-что еще!
      
      Добавляем фон в сцену
      
      Наш первый фон будет статическим. Воспользуемся следующим изображением:
      
      Импортируйте изображение в папку Textures (Текстуры). Просто скопируйте файл в нее, или перетащите его из проводника. Не беспокойтесь сейчас о настройках импорта.
      
      Создайте в Unity новый игровой объект Sprite на сцене.
      
      Что такое спрайт?
      
      По сути, спрайт – это 2D-изображение, используемое в видео-игре. В данном случае это объект Unity для создания 2D-игр.
      
      Добавляем текстуру спрайта
      
      Unity может автоматически установить фон для вашего спрайта. Если ничего такого не произошло, или если вы хотите изменить текстуру, перейдите на вкладку инспектора и выберите background : (фон)
      
      Вы должны нажать на маленький круглый значок справа от поля ввода, чтобы появилось Select Sprite (Выбрать спрайт) в Инспекторе
      
      Итак, мы создали простой спрайт отображающий облака на небе. Давайте внесем изменения в сцену. В панели Hierarchy (Иерархия) выберите New Sprite . Переименуйте его в Background1 или что-то такое, что легко запомнить. Переименуйте его в Background1 или что-то такое, что легко запомнить. Затем переместите объект в нужное место: Level -> 0 - Background . Измените координаты на (0, 0, 0) .
      
      Создайте копию фона и поместите его в (20, 0, 0) . Это должно отлично подойти к первой части.
      
      Слои со спрайтами
      
      Следующее утверждение очевидно, но обладает некими неудобствами: мы отображения 2D мир. Это означает, что все изображения на одной и той же глубине, то есть 0 . И вы графический движок не знает, что отображать в первую очередь. Слои спрайтов позволяют нам обозначить, что находится спереди, а что сзади.
      
      В Unity мы можем изменить "Z" наших элементов, что позволит нам работать со слоями. Это то, что мы делали в этом руководстве перед обновлением до Unity 5, но нам понравилась идея идея использовать слои со спрайтами. У вашего компонента Sprite Renderer есть поле с именем Sorting Layer с дефолтным значением. Если щелкнуть на нем, то вы увидите:
      
      Давайте добавим несколько слоев под наши нужды (используйте кнопку + ):
      
      Добавьте фоновый слой к вашему спрайту фона:
      
      Настройка Order in Layer - это способ ограничить подслои. Спрайты с меньшим номером оказываются перед спрайтами с большими числами.
      
      Слой Default нельзя удалить, так как это слой, используемый 3D-элементами. Вы можете иметь 3D-объекты в 2D игре, в частности, частицы рассматриваются как 3D-объекты Unity, так что они будут рендериться на этом слое.
      
      Добавление элементов фона
      
      Также известных как props. Эти элементы никак не влияют на геймплей, но позволяют усовершенствовать графику игры. Вот некоторые простые спрайты для летающих платформ:
      
      Как видите, мы поместили две платформы в один файл. Это хороший способ научиться обрезать спрайты с помощью новых инструментов Unity.
      
      Получение двух спрайтов из одного изображения
      
      Выполняйте следующие действия:
      1. Импортируйте изображения в папку "Текстуры"
      2. Выберите спрайт Platform и перейдите к панели Инспектор
      3. Измените "Sprite Mode" на "Multiple"
      4. Нажмите на кнопку Sprite Editor (Редактор спрайта)
      В новом окне ( Sprite Editor ) вы можете рисовать прямоугольники вокруг каждой платформы, чтобы разрезать текстуру на более мелкие части:
      
      Кнопка Slice в левом верхнем углу позволит вам быстро и автоматически проделать эту утомительную работу:
      
      Unity найдет объекты внутри изображения и будет нарежет их автоматически. Вы можете установить дефолтное значение для точки вращения или минимальный размер каждого фрагмента. Для простого изображения без артефактов, это необычайно эффективно. Тем не менее, если вы используете этот инструмент, будьте осторожны и проверьте результат, чтобы убедиться, что вы получили то, что хотели.
      
      В этом уроке проделаем эту операцию вручную. Назовите платформы platform1 и platform2 . Теперь, под файлом изображения, вы должны увидеть два спрайта отдельно:
      
      Добавим их в сцену. Для этого мы будем выполнять те же действия что и для фона: создадим новый спрайт и выберим platform1 . Потом повторим эти действия для platform2 . Поместите их в объект 1 - Middleground . Убедитесь, что их позиция по оси Z равна нулю.
      
      Prefabs (Префабы)
      
      Сохранить эти платформы как префабы. Просто перетащите их в папку Prefabs :
      
      Таким образом вы создадите Prefab , точно отвечающий оригинальному игровому объекту. Вы увидите, что игровой объект, который вы конвертировали в Prefab , представляет собой новый ряд кнопок прямо под его именем:
      
      Заметка о кнопках "Prefab": При последующей модификации игрового объекта, вы можете использовать кнопку "Apply", чтобы применить эти изменения к Prefab , или кнопку "Revert", чтобы отменить все изменения игрового объекта в свойстваъ Prefab . Кнопка "Select" переместит выбранные свойства в ассет Prefab в окне проекта (они будут выделены).
      
      Создание префабов с объектами-платформами упростит их повторное использование. Просто перетащите Prefab на сцену, чтобы добавить копию. Попробуйте добавить другую платформу таким же образом.
      
      Теперь вы можете добавить больше платформ, меняющих свои координаты, размеры и плоскости (вы можете поместить их на заднем или переднем плане, просто установите координату Z для платформы на 0 ).
      
      На данном этапе все это выглядит еще сыроватым, но в следующих двух главах мы добавим параллаксный скроллинг, и сцена оживет у нас на глазах.
      
      Прежде чем двигаться дальше, мы модифицируем наши слои, чтобы избежать каких-либо проблем с порядком их отображения. Для этого просто измените позицию игровых объектов по оси Z во вкладке Hierarchy (Иерархия) следующим образом:
      
      Слой Позиционирование по оси Z
      
      0 - Задний фон 10
      
      1 - Средний фон 5
      
      2 - передний фон 0
      
      При переключении из 2D режима в 3D, в окне "Scene" (Сцена) вы будете четко видеть слои:
      
      Кликнув на игровом объекте Main Camera , вы увидите, что флажок Projection установлен на Orthographic . Эта настройка позволяет камере визуализировать 2D игру без учета трехмерных свойств объектов. Имейте в виду, что даже если вы работаете с 2D объектами, Unity по-прежнему использует свой 3D движок для визуализации сцены. Рисунок выше это наглядно демонстрирует.
      
      В следующем уроке:
      
      Вы только что узнали, как создать простой статический фон и как отобразить его должным образом. Затем мы научили вас, как сделать простые спрайты. В следующей главе мы узнаем, как добавить игрока и его врагов.
      
      Программирование и разработка
      
      Из этой статьи вы узнаtте, как начать создавать игру с помощью Unity, начиная только с идеи. Кроме того, вы изучите хороший метод запуска для создания игр Unity 2d с нуля.
      
      Важно отметить, что это руководство не сделает из вас полноценного разработчика Unity и не научит программировать. Однако это поможет вам быстро заставить что-то работать на экране.
      
      Unity — один из самых популярных доступных бесплатных игровых движков. Он также имеет отличный 2D-движок, поэтому 3D-модели не нужны. Ещё одной привлекательной особенностью Unity является то, что он не требует обширных знаний в области программирования.
      
      Разработка игр с помощью Unity хороша для создания вещей, которые уже созданы. Короче говоря, Unity идеально подходит для разработки небольших инди-игр.
      
      Ниже приведено пошаговое руководство по созданию 2D-игры в Unity для начинающих.
      
      Шаг 1. Идея
      
      Шаг первый довольно прост. Вы легко можете сделать это в уме.
      
      Перед тем, как начать, определитесь, какую игру вы делаете. Чтобы понять это, вы должны задать себе несколько вопросов по игровому дизайну:
      - Это платформер, игра с видом сверху или, может быть, изометрическая?
      - Какая будет тема и основная история?
      - Как это будет выглядеть?
      - Какой движок вы будете использовать?
      - Главное, чем ваша игра будет выделяться? Какую новую механику или идею он представляет или что будет хорошо?
      Хотя вам не нужны твёрдые или конкретные ответы на большинство из этих вопросов, вам всё же необходимо общее представление о том, что вы собираетесь делать, прежде чем начать. Вы можете расширить эту идею и создать её базовый прототип позже. Кому-то нравится делать это на бумаге, а кто-то может просто провести мозговой штурм.
      
      Для начала сделаем платформер. В этом примере особое правило платформеров состоит в том, что игрок должен управлять двумя персонажами одновременно, чтобы решать головоломки, а персонажи должны встретиться, чтобы пройти уровень.
      
      Как только у вас появится несколько идей о том, что делать, у вас будет руководство, с которого можно начать. Теперь можно переходить к прототипированию.
      
      Шаг 2. Получите инструменты
      
      Чтобы создать игру в Unity, вам понадобится Unity. Вы можете скачать персональную версию здесь . Имейте в виду, что личная версия необходима только в том случае, если вы не получили более 100 тысяч долларов для финансирования или дохода от своей игры.
      
      Мы используем Unity версии 2019.2.14f1
      
      Вы также можете создавать графику для своей игры. Поскольку Unity использует пиксельную графику , я настоятельно рекомендую использовать GraphicsGale . GraphicsGale бесплатна, проста в использовании и обладает множеством функций. Однако вы можете свободно использовать любой удобный вам редактор, будь то Photoshop, Blender или Windows Paint.
      
      Шаг 3. Настройте свой проект
      
      Пока Unity устанавливается, вы можете потратить время на подготовку некоторых своих ресурсов. Вам понадобится некоторая замещающая графика, называемая заполнителями, чтобы вы могли видеть, что вы делаете. Чтобы нарисовать все анимации вашего персонажа, врагов и окружающую среду, потребуется время, поэтому вы можете начать работу с простой графикой.
      
      Для этого шага мы используем GraphicsGale, но вы можете использовать любой редактор, который вам нравится. Начните с того, что сделайте замену стен в игре. (Помните, вы всегда можете сделать больше позже.) Стены должны быть размером 100 на 100 пикселей.
      
      Сделайте что-нибудь быстрое и лёгкое, чтобы представить элементы нашей игры.
      
      После завершения загрузки Unity вы можете открыть Unity Hub и начать новый проект. Назовите проект как хотите, но не забудьте выбрать 2D для настройки проекта.
      
      Обязательно используйте 2D-шаблон.
      
      В Unity есть невероятная функция под названием Unity Asset Store. Asset Store полон готовых фрагментов игры, таких как модели, текстуры, утилиты или программы AI. Они доступны для продажи, а некоторые даже предлагаются бесплатно. Из-за этого легко создать игру, не создавая слишком много ресурсов самостоятельно. Вы можете просто взять заранее запрограммированную игровую механику и прикрепить её к собственному арту.
      
      Загрузите стандартные ресурсы из Unity Store.
      
      Вам также понадобятся некоторые инструменты для создания 2D-игр в Unity, которые вам немного помогут. Перейдите по этой ссылке и загрузите Git в виде zip-архива. Затем разархивируйте и перетащите папку внутри в обозревателя ресурсов. Возможно, вам придётся перезапустить Unity после этого, чтобы он работал правильно.
      
      Теперь у вас должно быть всё необходимое для начала работы.
      
      Шаг 4. Создайте карту
      
      Вы также захотите добавить свою иллюстрацию-заполнитель в браузер ресурсов. Просто перетащите всю папку из окон в обозревателя ресурсов.
      
      Ваша новая палитра плитки, там ещё ничего нет.
      
      Чтобы добавить искусство в палитру, просто перетащите свой заполнитель для блоков уровня в окно выше.
      
      Затем создайте что-нибудь для рисования с помощью палитры. В окне Hierarchy щёлкните правой кнопкой мыши и выберите 2D Object> Tilemap.
      
      Щёлкните здесь правой кнопкой мыши, чтобы создать карту листов.
      
      Теперь у вас должна быть возможность рисовать на своём уровне. Постарайтесь пока держать его в пределах границ камеры и добавить несколько платформ, на которые можно прыгать.
      
      Наконец, нужно позаботиться об одном последнем шаге. Прямо сейчас ваша карта — это только визуализация, и ваш персонаж не будет сталкиваться со стенами, которые вы построили. Фактически, ваш персонаж провалится прямо сквозь пол. Вы должны добавить свойство физики, чтобы игра знала, что эти квадраты имеют значение, и они созданы не только для того, чтобы красиво выглядеть.
      
      Компонент, который вам нужно добавить, называется Tilemap Collider 2D. Просто воспользуйтесь окном поиска, чтобы найти его и добавить на карту листов.
      
      Шаг 5. Сделайте персонажа
      
      Помните, как к вашей тайловой карте был прикреплён компонент столкновения? Что ж, нашему персонажу нужно много компонентов, прикреплённых к нему, чтобы функционировать. Вместо того, чтобы каждый раз перестраивать каждый компонент, вы можете создавать префабы, которые будут служить игровыми объектами. Их можно использовать снова и снова.
      
      Теперь перетащите мальчика-робота в свою сцену и щёлкните по нему в иерархии. Глядя на все компоненты, прикреплённые к нему, вы заметите, что у него есть система анимации, средство рендеринга спрайтов и несколько различных функций столкновения и управления.
      
      У него есть система анимации, средство визуализации спрайтов и несколько различных функций управления столкновениями и контроля.
      
      Хотя вы можете использовать его сейчас, вам следует создать собственного персонажа, который в итоге заменит его. Его спрайт и анимация будут служить вам заменой, пока вы продолжаете развиваться вокруг него.
      
      Поскольку идея игровой механики в этом уроке состоит в том, чтобы встретить двух персонажей, вам следует перетащить в сцену второго мальчика-робота, возможно, с другой стороны. Таким образом, каждый раз, когда вы играете в игру, вам придётся координировать свои действия, чтобы встретить двух персонажей.
      
      Шаг 6. Дорожная карта и сборка
      
      Дорожная карта — один из многих шагов, которые вы можете предпринять отсюда. Теперь, когда у вас есть прототип, вся трудоёмкая работа по настройке выполнена.
      
      Например, ваша дорожная карта может выглядеть примерно так:
      1. Добавить систему монет.
      2. Добавить здоровье и урон игрока.
      3. Основные враги.
      4. Проверка ошибок.
      5. Улучшить базовое искусство.
      6. Создавайте игровые сценарии и выигрывайте.
      7. Добавить элементы пользовательского интерфейса.
      8. Добавить систему меню.
      Это начинает рассматривать возможности игры в перспективе и помогает увидеть, сколько работы осталось между этим прототипом и готовой игрой. Знать это расстояние важно, так как у вас не всегда есть неограниченное время и внимание, которые можно вложить в игру.
      
      Дорожная карта также помогает контролировать ваши ожидания. После того, как вы создадите дорожную карту, следующим шагом будет следовать ей, продолжая улучшать свою игру.
      
      Заключение
      
      В этом руководстве вы познакомились только с началом создания игры. Остальное зависит от вас. У Unity есть активное сообщество, и существует множество обучающих ресурсов, которые выходят далеко за рамки этого простого игрового руководства. Некоторые из лучших учебных ресурсов включают в себя кодирование или дизайн игры Bootcamps. Путь к тому, чтобы стать разработчиком игр, начинается с вашей первой игры, какой бы простой она ни была.
      
      Читайте также: