Создание игр на unity3d для чайников. Выбор движка: Unity. Добавляем текстуру спрайта

Тестируем свежий 2D-kit от Unity и подробно описываем процесс создания нашего первого платформера

Отправить

В середине февраля создатели Unity выпустили 2D-kit — необычное приложение, созданное для всех начинающих игроделов. С его помощью любой желающий может собрать платформер, не утруждаясь долгим написанием кода. Программный код, модели и анимации подготовили разработчики, а вам остается только вникнуть в манипуляции с ними и создать ту игру, о которой вы всегда мечтали (если это, конечно, двухмерный платформер). Мы протестировали 2D-kit, создали собственный уровень и на его примере рассказываем, как быстро освоится с движком и выпустить первую игру.

С чего начать

Если вы ни разу не запускали Unity или, по каким-то причинам, слышите о нем впервые, кратко поясним основы интерфейса. Все окна и вкладки вы можете свободно передвигать в любое удобное для вас место, но изначально они расположены следующим образом: в левой части находится столбик иерархии, который показывает все объекты, находящиеся в сцене; сама сцена располагается в центре, а справа от нее окно инспектора показывает свойства выделенного объекта. Внизу вы увидите меню проекта и материалы, которые ему присвоены. Теперь разберемся с тем, чем отличается 2D-kit от обычного запуска Unity.

В стартовом меню движка у вас будет выбор: начать новый проект или перейти во вкладку обучения, а там запустить загруженный 2D-kit. Выбрав второй вариант, вы увидите вместо пустого полотна материалы игры и сможете творить буквально с двух кликов. Сперва необходимо создать сцену: найдите сверху Kit Tools и выберете вкладку Create New Scene .

Сцена создана, в иерархии сразу выстроилось множество непонятных объектов, но главное — появилась героиня, которая будет представлять игрока в будущем. Управление ею настроено заранее, так что об этом беспокоиться не стоит. Пока важно понять, что набор строчек под заголовком GameUtilities в иерархии должен перемещаться вместе с главной героиней, чтобы на старте не возникло проблем с управлением. Вот мы и подобрались к самому насущному: как создавать уровни?

В меню Window есть вкладка The Palette — это окно кисти, которое позволяет рисовать фундамент. Чтобы перейти к выбору нужной текстуры нажмите на TilesetRockWaterBlockers и выберете TilesetGamekit . Теперь у вас есть два вида кисти: трава и камень, имитирующий инопланетные постройки. Совмещать их, к сожалению, нельзя, так что заранее планируйте уровень в одном стиле или маскируйте шов подручными объектами, вроде кислотного озера.

Создание окружения

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

В первую очередь рекомендуем заглянуть в Interactables — это самый простой вид предметов, которые очень легко располагать и настраивать. Например, там есть «DestructableColumn» — колонна, разрушаемая при ударе жезлом. Мы поставили ее при входе в пещеру. Чтобы добавить ее в свой уровень просто перетащите колонну из папки на сцену. Таким же образом добавляются и другие предметы, такие как «MovingPlatform».

Вы, наверное, заметили, что при добавлении объектов правое окно инспектора сразу заполняется непонятными настройками, а рядом с движущейся платформой еще и путь какой-то красный отметился. Не беспокойтесь, сейчас мы с ними быстро разберемся. На самом деле, большинство иконок, ползунков и цифр вам не пригодится на первом этапе. Главное - заметить кнопочку Add Node в настройках платформы — она добавляет новую точку в пути движения островка. Все точки можно передвигать стрелочками по оси координат. Проблема в том, что изначально платформа двигается по принципу «туда-сюда», а если вы формируете квадрат, то вы, естественно, хотите, чтобы островок двигался по кругу. Для этого в подменю Moving Platform (Script) , там же, где находится Add Node , вам нужно выбрать надпись BACK_FORTH , что и означает «туда-сюда», и сменить ее на LOOP , что означает «по кругу».

Теперь у вас есть движущиеся платформы, как в каком-нибудь Mario . Более того, вы можете их вертеть и увеличивать, выбрав в левом верхнем углу нужный маркер. Чтобы вместе с платформой перемещался какой-нибудь предмет, например, шипы, вам необходимо перетащить его прямиком на платформу в списке иерархии. Уже только на основе этого формируется неплохая игра, но мы пойдем еще дальше.

Теперь добавим в нашу сцену нечто посложнее - злющего NPC. Враги находятся в папке Enemies , которая лежит там же, в Prefabs . Неважно, кого вы кинете на уровень: синего или розового монстра, внимательно присмотритесь к его настройкам. Самая первая - Transform — изменяет положение и размер объекта. Вторая - Sprite Renderer — позволяет его отзеркалить в разных координатах; для этого поставьте галочку рядом с X или Y . И уж совсем далеко внизу находится Enemy Behaviour , которая управляет поведением монстра. Важнейшие строчки в этом окне - это View Fov и View Direction . Первая определяет область зрения врага, а вторая ее вращает. Вы также сможете отрегулировать дистанцию взора в строчке View Distance , просто указав нужное число.

Интерактивные объекты

На этом этапе вы способны создать собственный уровень со скрытыми пещерами, летающими островами и разными типами врагов, и все это без единой строчки кода. Пришла пора усложнить собранную сцену более комплексными, связанными друг с другом, объектами. Мы установим дверь, которая будет открываться благодаря кнопке, расположенной в полу или на стене. Для этого нам понадобится дверь, лежащая в уже знакомой нам папке Interactables , но с ней мы ничего делать не будем. Основная работа пойдет над кнопкой PressurePad , которая и должна открывать путь.

Ее расположение может быть любым; нам важна настройка Pressure Pad (Script) , которая кроется глубоко внизу инспектора. В ней есть маленькое окошко On Pressed () с плюсиком внизу. Этот плюс добавляет реакцию чего бы то ни было в сцене на нажатие кнопки. Поскольку нам надо, чтобы открывалась дверь, то именно дверь и нужно перетащить из окна иерархии в строку под надписью Runtime Only .

Мы связали между собой кнопку и дверь, но пока не определили, какой будет эта связь. Для того чтобы назначить ее нужно зайти в подменю No Function и в том списке, который выпадет при наведении на Animator , выбрать Play (string) . Вуаля! Опробуйте результат, просто нажав на кнопку Play , расположенную над сценой.

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

Связываются точки перехода еще проще, чем дверь с кнопкой. Они находятся в папке Scene Control , которая, как и все прочие папки с объектами, лежит в Prefabs . Там нам понадобится объект TransitionStart , который является точкой перехода. Если вы хотите создать телепорт внутри сцены, то вам понадобится две таких точки, одна из которых обязательно должна быть переименована в TransitionEnd (делается это в верхней строке инспектора).

Наберитесь терпения, потому что сейчас придется плотно поработать с настройками точки отправления, которые называются Transition Point (Script) . Первое поле говорит нам о том, какой объект будет переноситься. Поэтому из иерархии в него нужно перетащить героиню (Ellen ).

Вторая строка отвечает за тип перехода: внутри зоны или вне - это как перелет внутри страны или за границу. Если вы выбрали внутреннее путешествие, то перетащите в новое поле TransitionEnd — так вы укажите куда произойдет переход. Обычно перемещение происходит автоматически, поэтому следующей строкой стоит надпись On Trigger Enter , но вы можете изменить это по своему желанию, как это сделали мы у корабля. Не забудьте также перетащить Ellen в настройки TransitionEnd , иначе чуда не свершится.

Если вы переходите в другую локацию, то вам сперва нужно выбрать ее, а затем уже точку перехода, потому что на уровне их может быть несколько, и все они помечаются буквами в алфавитном порядке. Кстати, местом назначения в другом уровне служит объект под названием TransitionDestination , который находится там же, в Scene Control . Не перепутайте!

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

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

Второй секрет — это оформление. Деревья, трава, столбы, статуи и другие декоративные украшения располагаются в папке Sprites , которая лежит внутри папки Art. В этом нет ничего тайного, но вы можете пополнять библиотеку из магазина Unity или самостоятельно рисуя в Photoshop . Они могут как спрятаться за другими объектами, так и перекрывать их — за это отвечает цифра в строке Order in Layer .

Третий секрет — музыка. Он совсем простой: кидаете свой саундтрек в папку Music , а затем перетаскиваете его в настройки BackgroundMusicPlayer .

И последний секрет — смерть. Если вы строите открытые локации, в которых игрок может запросто упасть со скалы, вам необходимо подготовить для него штраф, а иначе он продолжит бесконечно парить. Лучше всего для этого подходит невидимая смерть. Создайте пустой объект и прикрепите к нему Damager (Script) . Растянув его по всей карте, вы получите ту самую невидимую смерть, от которой игрок будет гибнуть, падая с высоты.

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

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

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

В версии Ubuntu 11.04, произошло серьезное изменение в графической среде пользователя, теперь вместо GNOME в его традиционном виде все "крутится" под Unity. Так, что теперь Ubuntu еще больше похожа на Mac OS X.

Пустой рабочий стол Unity:

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

Кроме этого, в меню Dash есть Линзы (Dash Lens). Это переключатели для поиска только в определенных категориях и местах. Можно пролистать все установленные программы если воспользоваться линзой "Программы" :

Существует набор линз для разных предметных областей. Например есть линза "Википедия":

По умолчанию, "из коробки" устанавливаются линзы "Home", "Программы", "Файлы", "Музыка" и "Видео". Дополнительные линзы можно установить через репозиторий Ubuntu или сторонние репозитории.

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

Важное примечание

Относительно Unity нужно знать несколько вещей:

  • Для работы Unity необходимо установить драйвера на видеокарту, которые поддерживают OpenGL, а также движок визуальных эффектов Compiz. В Ubuntu 11.04 Compiz устанавливается автоматически, а подходящий драйвер может не установиться автоматически и в этом случае Ubuntu 11.04 будет загружаться с обычным рабочим столом GNOME.
  • В Ubuntu 11.04 вы можете отказаться от использования Unity и работать в GNOME привычного вида. Для этого нужно всего лишь завершить сеанс пользователя и заново войти в систему выбрав на логин-экране опцию "Ubuntu Классический". Эта опция доступна внизу логин-экрана после ввода имени пользователя (но ее нужно выбрать до ввода пароля!).
  • Если ваша видеокарта не поддерживает OpenGL, можно установить пакет Unity-2d, который рабтает как надстройка над GNOME.

Актуализация 2013

В версии 12.04 П акет Unity-2d устанавливается "из коробки". Для загрузки в облегченном варианте нужно просто выбрать Unity-2d в экране авторизации (до ввода пароля).

Кнопка Dash перемещена из верхней панели в левую боковую панель быстрого запуска (Launcher). Но физически она осталась почти на том же месте - вверху слева.

Организация интерфейса в Unity

Вверху экрана размещается панель которая содержит (слева направо ) кнопку открытия меню Dash, пространство для меню программ и системный трей.

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

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

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

Меню Наутилуса размещено в верхней панели Unity. Слева панель быстрого запуска (Launcher) с кнопками для запуска часто используемых программ. По вертикали под Наутилус используется почти все пространство монитора, за исключением 24 пикселей на верхнюю панель Unity.

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

Как пользоваться Unity

Собственно ничего принципиально нового эта оболочка не предлагает. Точно также как и раньше программы запускаются либо кнопками непосредственно с панели быстрого запуска (Launcher) , либо через общее меню Dash. Запущенные программы отображаются в той же панели быстрого запуска, такими же значками, только их значки выделены светлым треугольничком или двумя.

Как вставить кнопку запуска программы в панель быстрого запуска (Launcher) ?

Как удалить кнопку запуска программы из панели запуска?


Настройка Unity

Для того, чтобы изменить настройки Unity нужно установить пакет compizconfig-settings-manager, который по умолчанию не устанавливается. После его установки в Dash можно ввести "ccsm" и появится программа "Менеджер настроек CompizConfig".
В окне программы нужно открыть раздел "Рабочий стол" и там будет виден "Unity".

Актуализация 2013

Теперь есть еще одна программа для настройки интерфейса Unity -MyUnity , пакет для установки так и называется - myunity:

Использование клавиатуры в Unity

Unity еще более, чем классический GNOME, унифицирован с Windows по клавиатурным комбинациям. Теперь нажатие обеих (и правой и левой) клавиш Win дает одинаковый результат.

  • F10 - активизировать трей. Затем можно перемещаться по элементам трея стрелками.
  • Win - открыть меню программ (Dash) с поиском. По мере того как вы вводите буквы в поле, программа выдает вам подходящие варианты. Поиск работает как по английскому языку (оригинальному имени программ) так по русскому - именам ярлыков программ.
  • Alt+Tab - переход между окнами запущенных программ.
  • Win+D - свернуть все окна и освободить рабочий стол. В Ubuntu 11.10 сделали Ctrl+Alt+D.
  • Win+R - диалог "Выполнить", ранее открываемый по Alt+F2. В нем можно вписать однострочную терминальную команду. Есть поиск по истории введенных команд. В Ubuntu 11.10 снова сделали Alt+F2 .
  • Tab или стрелки вверх\вниз\вправо\влево - перемещение в меню.
  • Win+S - показать 4 рабочих стола сразу.
  • Win+Tab - при нажатии этого сочетания на каждой кнопке появляется номер, нажав этот номер на клавиатуре можно запустить\перейти в эту программу. Нужно удерживать нажатой Win до ввода цифры.
  • Ctrl+L - изменить режим адресной строки в Наутилусе с "табов" на текстовый.

Переопределить сочетания клавиш можно через апплет "Клавиатура" и через CompizConfig:

Тюнинг рабочего стола

Во-первых можно использовать "Менеджер настроек CompizConfig" для настроек различных визуальных эффектов.

Во-вторых можно установить дополнительные пакеты, которые реализуют какие-либо функции управления или удобства. Например пакет Glx-Dock (также известный как Cairo-Dock) реализует Dock панель в стиле Mac OS X и эту панель можно использовать для размещения кнопок запуска программ, которые не вмещаются на панели Unity. Выглядит это примерно так:

Для любителей глубоко копнуть

Если ваша программа не отображается в трее, хотя и должна можно попробовать вот такие команды:

gsettings set com.canonical.Unity.Panel systray-whitelist "["all"]"
gsettings set com.canonical.Unity.Panel systray-whitelist "[""]"
gsettings set com.canonical.Unity.Panel systray-whitelist "["имя_вашей_программы"]"

Если вы хотите изменить контекстные меню кнопок из панели запуска то сделать это можно скопировав файл нужной кнопки из папки /usr/share/applications в папку ~/.local/share/applications. Эти файлы имеют расширение.desktop. например nautilus-home.desktop.

Например так:


Name=Изображения
Exec=nautilus Изображения
TargetEnvironment=Unity


Name=Загрузки
Exec=nautilus Загрузки
TargetEnvironment=Unity

Можно еще глубже копнуть:

Или на телефон +7 918-16-26-331 .

Даже небольшая сумма может помочь написанию новых статей:)

Как создать игру в Unity

Казуальные игры в жанре match 3 (три в ряд) - одни из самых популярных на рынке. Многие играют в Candy Crush, Bejeweled и прочие. У этих игр простая цель: перемещать мозаичные элементы до тех пор, пока три одинаковых элемента не окажутся рядом. Когда это происходит, совпавшие элементы исчезают, а на их месте появляются другие. Игрок при этом набирает баллы.

В этом руководстве будут освещаться следующее:

  • Создание доски, заполненной мозаичными элементами
  • Выбор и отмена выбора мозаичных элементов
  • Идентификация соседних элементов с помощью raycasts
  • Замена элементов
  • Поиск совпадающих трех и более элементов с помощью raycasts
  • Заполнение пустых элементов
  • Ведение счета и подсчет движений

Примечание . Предполагается, что вы уже знаете, как пользоваться редактором Unity, как редактировать код, и что у вас есть базовые знания по части C#.

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

Share this article:

Related Articles

Наткнулся на англоязычную статью 2012-го года, от немецкого автора, фрилансера-геймдевелопера, разработчика инструментов для Юнити — Herman Tulleken. В статье, сведены 50 советов по работе в Юнити. Советы основаны на опыте работы автора в проектах, с командами от 3 до 20 человек. Автор предупреждает, что не все из них, могут быть применены в каждом проекте; многие советы — дело вкуса. От себя добавлю, что Юнити эти 3 года не стоял на месте, и возможно некоторые советы, могут быть уже не актуальны. Перевода я не нашел. Подумал, а почему бы мне ее не перевести ее, для своего сайта.

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

Процесс

1. Избегайте разветвленных ассетов. Всегда, должна быть только одна версия, любого ассета. Если вам абсолютно необходимо ответвить новую версию префаба, сцены или сетки, следуйте процессу, это сделает ясным, какая версия является правильной. «Неправильная» версия должна иметь броское имя, например, использовать двойное подчеркивание префикс: __MainScene_Backup . Ветвление префабов требует определенного процесса, чтобы сделать его безопасным (см в разделе Префабы).

2. Каждый член команды, должен иметь второй экземпляр проекта для тестирования, если вы используете систему контроля версий. Все изменения должны делаться, и тестироваться в нём, и затем вносится в «чистовую» версию. Никто не должен делать какие-либо изменения в их «чистовых» экземплярах. Это особенно полезно, чтобы отловить недостающие ассеты.

3. Рассмотрите возможность использования внешних инструментов для редактирования уровня. Юнити не лучший инструмент для этого. Например, мы использовали TuDee для создания уровней на основе 3D-тайлов, где есть такие полезные функции, как: привязка к сетке, 2D вид, быстрый выбор тайлов. Простое инстанцирование префабов из XML-файлов.

4. Рассмотрите сохранение уровней в XML, а не в сценах. Это прекрасный метод:

  • это избавляет от необходимости настраивать каждую сцену;
  • это делает загрузку намного быстрее (если большинство объектов являются общими для всех сцен).
  • это делает легче объединение сцен.
  • это делает более легким отслеживание данных уровня.

Вы по-прежнему сможете использовать Unity в качестве редактора уровня (хотя и не должны). Вам нужно будет написать код для сериализации и десериализации данных, для загрузки уровня в редакторе и во время выполнения, а также для сохранения уровня в редакторе. Вам также может понадобиться, имитировать ID систему Unity, для поддержания ссылок между объектами.

5. Рассмотрите написание пользовательского инспектора. Написать пользовательский инспектор довольно просто, но система Unity имеет много недостатков:

  • Он не позволяет воспользоваться преимуществами наследования.
  • Он не позволяет определить компоненты инспектора на уровне поля, только на уровне класса. Например, если каждый игровой объект, имеет поле типа SomeCoolType , который вы хотите отобразить в инспекторе иначе, вы должны написать инспектор для каждого класса.

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

Организация сцены

6. Используйте именованные пустые объекты, как папки. Тщательно организовывайте свои сцены, чтоб облегчить поиск объектов в них.

7. Помещайте при редактировании свои префабы и папки (пустышки) в нулевые координаты (0, 0, 0). Если префаб/пустышка редактируется не для позиционирования, он должен быть в нуле. Таким образом, уменьшается вероятность возникновения проблем с локальными и мировыми системами координат, и код как правило проще.

8. Минимизируйте использование смещений для компонентов GUI. Смещения должны использоваться для компоновки компонентов, только относительно их родительского контейнера; они не должны полагаться на позиционирование своих прародителей. Смещения не должны отменять друг друга, чтобы правильно отображаться. Это в основном для предотвращения такого рода вещей:

Родительский контейнер произвольно размещен в (100, -50). Ребенок, предназначенный для позиционирования в точке (10, 10), помещен в (90, 60) [относительно родительского].

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

9. Размещайте вашу землю на y=0. Это облегчает задачу размещение объектов на земле.

10. Делайте игру, готовую к запуску в каждой сцене. Это значительно сокращает этап тестирования. Для этого нужно сделать 2 вещи:

Во-первых, предоставить в сцене все данные, требующиеся от предшествующих сцен, если они не доступны.

Во-вторых, создайте объекты, которые должны сохраняться между загрузками сцены, следующим образом:

myObject = FindMyObjectInScene();

if (myObjet == null)
{
myObject = SpawnMyObject();
}

Арт

11. Размещайте пивот поинты (точки вращения) в основании объектов и персонажей, а не в центре. Это упрощает установку объектов, точно на поверхность. Так же это позволяет работать с 3d, как с 2d в игровой логике, AI, и даже в физике, когда это необходимо.

12. Ориентируйте все ваши объекты, включая персонажей, «лицом» вдоль одной и той же оси (положительное или отрицательное направление оси Z). Многие алгоритмы упрощаются, когда все объекты лицом направлены в одном направлении. Тут имеются ввиду, локальные оси самого объекта, а не мировые.

13. Позаботьтесь о правильном масштабе своих ассетов, до импорта в движок. При масштабе (1, 1, 1) они должны иметь задуманные размеры. Для сравнения, можно использовать ссылку на объект куба в юнити, находящийся в стандартных ассетах. Выберите подходящее соотношения к мировым единицам, и придерживайтесь его.

14. Чтобы, было легче размещать и ориентировать GUI и партиклы, используйте two-poly plane (плоскость из двух треугольников). Сориентируйте плоскость лицом по оси Z (см. пункт 12) и вкладывайте в нее GUI или партиклы.

15. Создайте и применяйте тестовые арты:

  • Меченые квадраты для скайбоксов.
  • Текстуру с сеткой.
  • Различные «плоские» цвета для шейдерного тестирования: белый; черный; 50% серого; красный; зеленый; синий; пурпурный; желтый; голубой.
  • Градиенты для шейдерного тестирования: от черного к белом; от красного к зеленому; от красного к синему; от зеленого к синему.
  • Текстуру «чекер» (черно-белые квадраты, по типу шахматной доски).
  • Сглаженные и жесткие карты нормалей.
  • Готовое и настроенное освещение, для быстрого создания тестовых сцен.

Префабы

16. Используйте префабы абсолютно для всего. Единственные объекты, которые не должны быть префабом, это папки. Даже уникальные объекты, которые будут использованы только раз, должны быть префабом. Это облегчает внесение изменений в сцены, не трогая сами сцены. (Дополнительным преимуществом является то, что это делает построение атласа спрайтов надежнее, при использовании EZGUI).

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

  • вносить изменения для каждого типа в одном месте;
  • вносить изменения без изменения сцены.

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

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

19. Насколько это, возможно, устанавливайте связи между экземплярами автоматически. Если вам необходимо установить связь между экземплярами, делайте это программно (в коде). Например, префаб игрока может зарегистрировать себя в GameManager , когда он стартует. Или GameManager может сам найти экземпляр префаба игрока, когда он стартует.

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

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

20. Используйте безопасный процесс ветвления префабов. Объясним на примере префаба Player .

Делать опасные изменения в префабе, нужно следующим образом:

  • Скопировать префаб Player .
  • Переименовать дубликат на __Player_Backup .
  • Сделайте изменения в префабе Player .
  • Если все работает, удалить __Player_Backup .

Не называйте дубликат Player_New , и не вносите в него изменения!

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

Разработчик 1:

  • Скопировать префаб Player .
  • Переименовать его в __Player_WithNewFeature или __Player_ForDev .
  • Сделать изменения в дубликате, закоммитить / передать 2-му разработчику.

Разработчик 2:

  • Внести изменения в новый префаб.
  • Скопировать префаб Player , и назвать его __Player_Backup .
  • Перетащить экземпляр __Player_WithNewFeature на сцену.
  • Перетащите экземпляр на оригинальный префаб Player .
  • Если все работает, удалить __Player_Backup и __Player_WithNewFeature .

Расширения и MonoBehaviourBase

21. Расширьте MonoBehaviour своим поведением, и получайте все ваши компоненты от него. Это позволяет реализовать некоторую общую функциональность, такие как типобезопасного вызова (Invoke), и более сложные вызовы (например, случайный, и т.д.).

22. Определите безопасные методы для методов Invoke, StartCoroutine и Instantiate. Определите делегат Task, и используйте его, для определения методов, которые не зависят от имени. Например:

public void Invoke(Task task, float time)
{
Invoke(task.Method.Name, time);
}

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

Реализации ниже используют TypeOf , вместо обобщенных версий этих функций. Обобщенные версии не работают с интерфейсами. Методы ниже, обертывают TypeOf-версии в обобщенные методы.

//Defined in the common base class for all mono behaviours
public I GetInterfaceComponent() where I: class
{
return GetComponent(typeof(I)) as I;
}

Public static List FindObjectsOfInterface() where I: class
{
MonoBehaviour monoBehaviours = FindObjectsOfType();
List list = new List();

Foreach(MonoBehaviour behaviour in monoBehaviours)
{
I component = behaviour.GetComponent(typeof(I)) as I;

If(component != null)
{
list.Add(component);
}
}

Return list;
}

24. Используйте расширения, чтобы сделать синтаксис более удобным. Например:

public static class CSTransform
{
public static void SetX(this Transform transform, float x)
{
Vector3 newPosition =
new Vector3(x, transform.position.y, transform.position.z);

Transform.position = newPosition;
}
...
}

25. Используйте безопасную альтернативу GetComponent. Иногда внедрение зависимостей компонентов (через RequiredComponent ), может быть болезненным. Например, это затрудняет изменение компонентов в инспекторе (даже, если они имеют тот же базовый тип). В качестве альтернативы, может быть использовано, следующее расширение GameObject , для вывода ошибки, если компонент не найден.

public static T GetSafeComponent(this GameObject obj) where T: MonoBehaviour
{
T component = obj.GetComponent();

If(component == null)
{
Debug.LogError("Expected to find component of type "
+ typeof(T) + " but found none", obj);
}

Return component;
}

Идиомы

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

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

Примеры групп идиом:

  • Сопрограммы vs конечного автомата.
  • Вложенные префабы vs связанные префабы vs «Бог»-префабы.
  • Стратегии разделения данных.
  • Способы использования спрайтов для состояний в 2D-игр.
  • Структура префаба.
  • Стратегии спауна (spawning).
  • Способы поиска объектов: по типу vs по имени vs по тегу vs по слою vs ссылке.
  • Способы группировки объектов: по типу vs по имени vs по тегу vs по слою vs массиву или ссылкам.
  • Поиск групп объектов vs self-registration.
  • Контроль порядка выполнения (использовать установленный порядок исполнения Unity vs логику yield vs Awake/Start и Update/Late Update vs ручные методы vs в любом порядке).
  • Выделение объектов / позиции / целей с помощью мыши в игре: менеджер выделения vs локальный self-management.
  • Хранение данных между изменениями сцены: через PlayerPrefs, или объекты, которые не уничтожаются при загрузке новой сцены.
  • Способы комбинирования (смешивания, добавления и наслаивание) анимации.

(*vs — против)

Время

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

Спаун объектов

28. Не позволяйте порождаемым объектам загромождать иерархию, когда игра запущена. Установите для них родителя — объект сцены, для облегчения поиска объектов, при запущенной игре. Вы можете воспользоваться пустым объектом игры, или даже единичным объектом без поведения, чтобы легко получить доступ из кода. Вызовите этот объект DynamicObjects .

Дизайн классов

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

public class Singleton : MonoBehaviour where T: MonoBehaviour
{
protected static T instance;

/**
Returns the instance of this singleton.
*/
public static T Instance
{
get
{
if(instance == null)
{
instance = (T) FindObjectOfType(typeof(T));

If (instance == null)
{
Debug.LogError("An instance of " + typeof(T) +
" is needed in the scene, but there is none.");
}
}

Return instance;
}
}
}

Синглтоны полезны, для различных менеджеров, таких как ParticleManager , или AudioManager , или GUIManager .

  • Избегайте использования синглтонов для уникальных экземпляров префабов, которые не менеджеры (например, экземпляр Игрока). Не соблюдение этого принципа, усложняет иерархию наследований, и делает некоторые изменения сложнее. Вместо этого, держите ссылки на такие экземпляры в вашем GameManager (или другом подходящем «Бог»-классе;-)).
  • Определите статические свойства и методы для публичных переменных и методов, которые часто используются за пределами класса. Это позволит вам писать GameManager.Player вместо GameManager.Instance.player .

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

public float __aVariable;

31. Отделяйте интерфейс от логики игры. Это, по сути паттерн MVC.

Каждый контроллер ввода, должен лишь давать команды соответствующим компонентам, чтобы дать им знать, что контроллер был вызван. Например, в логике контроллера, можно решать, какие команды давать, основываясь на состоянии игрока. Но это плохо (например, это приведет к дублированию логики, если добавлено несколько контроллеров). Вместо этого, объект Игрока должен быть уведомлен о намерениях двигаться вперед, а затем на основе текущего состояния (замедлен или оглушен, например) установить скорость и обновить направление игрока. Контроллеры должны делать только то, что относится к их собственному состоянию (контроллер не меняет состояние, когда игрок изменяет состояние, поэтому контроллер вообще не должен знать о состоянии игрока). Другим примером является смена оружия игроком. Правильный способ сделать это в Player , с помощью метода SwitchWeapon(Weapon newWeapon) , который можно вызвать из GUI. GUI не должен манипулировать трансформациями, родителями и т.д..

Любой компонент интерфейса, должен только поддерживать данные, и выполнять обработку, связанную с его собственным состоянием. Например, отображение карты, на основе расчетов движения игрока. Тем не менее, это данные состояния игры, и не принадлежат к GUI. GUI должен лишь отображать данные состояния игры, хранить их нужно в другом месте. Картографические данные должны быть сохранены в другом месте (в GameManager , например).

Объекты геймплея не должны знать практически ничего о GUI. Единственным исключением является режим паузы, которая может контролироваться глобально посредством Time.timeScale (что не является хорошей идеей). Геймплейные объекты должны знать, если игра приостановлена. И это всё. Поэтому, не должно быть ссылок, на GUI-компоненты из объектов геймплея.

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

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

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

  • сохранение состояния игры
  • отладку состояния игры

Один из способов сделать это, определение класса SaveData для каждого класса игровой логики:


PlayerSaveData
{
public float health; //public for serialisation, not exposed in inspector
}

Player
{
//... bookkeeping variables (переменные промежуточных данных)

//Don’t expose state in inspector. State is not tweakable.
private PlayerSaveData playerSaveData;
}

33. Отделяйте конфигурацию специализаций.

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

  • Определите шаблонный класс для каждого класса игровой логики. Для экземпляра врага, мы определим класс EnemyTemplate . Где будут храниться, все отличительные характеристики.
  • В классе игровой логики, определите переменную типа нашего шаблона.
  • Сделайте префаб врага, и два шаблонных префаба WeakEnemyTemplate и StrongEnemyTemplate .
  • При загрузке и порождении объектов, задайте переменной шаблона нужный шаблон.

Этот метод может стать довольно сложным (а иногда, излишне сложным, так что будьте осторожны!).

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

public class BaseTemplate
{
...
}

Public class ActorTemplate: BaseTemplate
{
...
}

Public class Entity where EntityTemplateType: BaseTemplate
{
EntityTemplateType template;
...
}

Public class Actor: Entity
{
...
}

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

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

public void SelectWeapon(int index)
{
currentWeaponIndex = index;
Player.SwitchWeapon(weapons);
}

Public void Shoot()
{
Fire(bullets);
FireParticles(particles);
}

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


public class Weapon
{
public GameObject prefab;
public ParticleSystem particles;
public Bullet bullet;
}

Код выглядит аккуратнее, а главное, так труднее совершить ошибку в настройке данных в инспекторе.

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

public void FireAttack()
{
/// behaviour
Fire(bullets);
}

Public void IceAttack()
{
/// behaviour
Fire(bullets);
}

Public void WindAttack()
{
/// behaviour
Fire(bullets);
}

Перечисления могут сделать ваш код лучше …

public void WindAttack()
{
/// behaviour
Fire(bullets);
}

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


public class Bullets
{
public Bullet FireBullet;
public Bullet IceBullet;
public Bullet WindBullet;
}

Здесь предполагается, что нет других данных для огня, льда и воздуха.

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

  • Определите отдельные классы для групп переменных. Сделайте их публичными и сериализуемыми.
  • В основном классе, определите публичные переменные каждого типа, как указанно ранее.
  • Не инициализируйте эти переменные в Awake или Start ; так как они сериализуемые, Unity позаботится об этом.
  • Вы можете указать значения по умолчанию, до присвоения значений в определении.

Это сгруппирует переменные в инспекторе в блоки, и облегчит управление ими.


public class MovementProperties //Not a MonoBehaviour!
{
public float movementSpeed;
public float turnSpeed = 1; //default provided
}

Public class HealthProperties //Not a MonoBehaviour!
{
public float maxHealth;
public float regenerationRate;
}

Public class Player: MonoBehaviour
{
public MovementProperties movementProeprties;
public HealthPorperties healthProeprties;
}

Текст

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

39. Если вы планируете локализовать отдельно все строки в одном месте. Есть много способов сделать это. Один из способов заключается в определении класса Text , с публичным полем для каждой строки, и заданным значением по умолчанию на английском, например. Другой языковой подкласс, повторно инициализирует поля языковым эквивалентом.

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

Тестирование и отладка

42. Реализуйте свой собственный FPS-счетчика. Да. Никто не знает, что на самом деле измеряет FPS-счетчик Unity, но это не скорость кадров. Реализуйте собственный, так чтобы FPS соответствовал интуиции и визуальному контролю.

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

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

45. Реализуйте опции отладки для упрощения тестирования. Некоторые примеры:

  • Разблокировать все предметы (айтемы).
  • Отключить врагов.
  • Отключить GUI.
  • Сделать игрока непобедимым.
  • Отключить весь геймплей.

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

  • Члены команды не закоммитят свои опции отладки по случайности, и никого не затронут.
  • Изменение опций отладки не изменит сцену.

47. Держите сцену со всеми элементами геймплея. Например, сцена со всеми врагами, все объекты, с которыми можно взаимодействовать, и т.д. Это делает легкой проверку функциональности, без необходимости играть слишком долго.

48. Определите константы для отладки сочетания клавиш, и держите их в одном месте. Клавиши отладки не нормально (не удобно) обрабатываются в едином месте, как и остальные части игрового ввода. Чтобы избежать конфликтов между сочетаниями клавиш, определите константы в одном месте. Альтернативой является, обрабатывать все клавиши в одном месте, независимо от того, является функция отладочной, или нет. (Недостатком является то, что этому классу могут понадобиться дополнительные ссылки на объекты).

Документация

49. Документируйте ваши настойки. Большинство документации должно быть в коде, но некоторые вещи должны быть задокументированы вне кода. Документация, повышает эффективность (если она актуальная).

Документируйте следующее:

  • Использование слоя (для коллизий, Culling, и Raycasting — по сути то, что должно быть на слое).
  • Использование тэгов.
  • Глубина GUI для слоев (что должно отображаться, поверх чего).
  • Настройка сцены.
  • Идиома предпочтений.
  • Структуры префабов
  • Слои анимации.

Стандарт именования и структура папок

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

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

Общие принципы именования.
  • Называйте вещи своими именами. Птица должна называться Bird .
  • Выбирайте имена, легко произносимые и запоминающиеся. Если вы делаете игру о Майя, не называйте свой уровень QuetzalcoatisReturn .
  • Будьте последовательными. Выбрав имя, придерживайтесь его.
  • Используйте стиль PascalCase, например: ComplicatedVerySpecificObject . Не используйте пробелы, подчеркивания или дефисы, с одним исключением (см. «Именования различных аспектов одного и того же»).
  • Не используйте номера версий, или слова для обозначения стадии прогресса (WIP, финал).
  • Не используйте аббревиатуры: DVamp@W должно быть DarkVampire@Walk .
  • Используйте терминологию из дизайн документации: если в документе анимация смерти называется Die, то надо использовать имя DarkVampire@Die , а не DarkVampire@Death .
  • Держите наиболее специфический дескриптор слева: DarkVampire , вместо VampireDark ; PauseButton , вместо ButtonPaused . Легче, например, найти кнопку паузы в инспекторе, когда не все кнопки, начинаются со слова «Button». [Многие люди предпочитают делать наоборот, потому что, это делает группировки, визуально более очевидными. Имена существуют не для группировок, для этого есть папки. Имена для различения объектов, одного и того же типа, и они должны помогать делать это быстро.]
  • Некоторые имена образуют последовательность. Используйте номера в этих названиях, например, PathNode0 , PathNode1 . Всегда начинайте с 0, а не 1.
  • Не используйте цифры для вещей, которые не образуют последовательность. Например, Bird0 , Bird1 , Bird2 , должно быть Flamingo , Eagle , Swallow .
  • Ставьте префикс временным объектам в виде двойного подчеркивания __Player_Backup .
Именования различных аспектов одного и того же

Используйте подчеркивание между основным именем, и тем, что описывает «Аспект». Например:

  • Состояние GUI-кнопок: EnterButton_Active, EnterButton_Inactive.
  • Текстуры: DarkVampire_Diffuse, DarkVampire_Normalmap.
  • Скайбоксы: JungleSky_Top, JungleSky_North.
  • LOD-группы: DarkVampire_LOD0, DarkVampire_LOD1.

Не используйте, это соглашение просто, для различия типов предметов, например, Rock_Small , Rock_Large , должно быть SmallRock , LargeRock .

Структура

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

Структура папок:

Materials
GUI
Effects
Meshes
Actors
DarkVampire
LightVampire
...
Structures
Buildings
...
Props
Plants
...
...
Plugins
Prefabs
Actors
Items
...
Resources
Actors
Items
...
Scenes
GUI
Levels
TestScenes
Scripts
Textures
GUI
Effects
...

Структура сцены:

Cameras
Dynamic Objects
Gameplay
Actors
Items
...
GUI
HUD
PauseMenu
...
Management
Lights
World
Ground
Props
Structure
...

Структура папки скриптов:

ThirdParty
...
MyGenericScripts
Debug
Extensions
Framework
Graphics
IO
Math
...
MyGameScripts
Debug
Gameplay
Actors
Items
...
Framework
Graphics
GUI
...

Как переопределить отрисовку инспектора.

1. Определите базовый класс для всех ваших редакторов:

BaseEditor : Editor
where T: MonoBehaviour
{
override public void OnInspectorGUI()
{
T data = (T) target;

GUIContent label = new GUIContent();
label.text = "Properties"; //

DrawDefaultInspectors(label, data);

If(GUI.changed)
{
EditorUtility.SetDirty(target);
}
}
}

2. Используйте рефлексию и рекурсию, чтобы составить компоненты:

public static void DrawDefaultInspectors(GUIContent label, T target)
where T: new()
{
EditorGUILayout.Separator();
Type type = typeof(T);
FieldInfo fields = type.GetFields();
EditorGUI.indentLevel++;

Foreach(FieldInfo field in fields)
{
if(field.IsPublic)
{
if(field.FieldType == typeof(int))
{
field.SetValue(target, EditorGUILayout.IntField(
MakeLabel(field), (int) field.GetValue(target)));
}
else if(field.FieldType == typeof(float))
{
field.SetValue(target, EditorGUILayout.FloatField(
MakeLabel(field), (float) field.GetValue(target)));
}

///etc. for other primitive types

Else if(field.FieldType.IsClass)
{
Type parmTypes = new Type{ field.FieldType};

String methodName = "DrawDefaultInspectors";

MethodInfo drawMethod =
typeof(CSEditorGUILayout).GetMethod(methodName);

If(drawMethod == null)
{
Debug.LogError("No method found: " + methodName);
}

Bool foldOut = true;

DrawMethod.MakeGenericMethod(parmTypes).Invoke(null,
new object
{
MakeLabel(field),
field.GetValue(target)
});
}
else
{
Debug.LogError(
"DrawDefaultInspectors does not support fields of type " +
field.FieldType);
}
}
}

EditorGUI.indentLevel--;
}

Описанный выше метод использует вспомогательный метод:

private static GUIContent MakeLabel(FieldInfo field)
{
GUIContent guiContent = new GUIContent();
guiContent.text = field.Name.SplitCamelCase();
object descriptions =
field.GetCustomAttributes(typeof(DescriptionAttribute), true);

If(descriptions.Length > 0)
{
//just use the first one.
guiContent.tooltip =
(descriptions as DescriptionAttribute).Description;
}

Return guiContent;
}

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

3. Определите новые пользовательские редакторы.

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


public class MyClassEditor: BaseEditor
{}

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

Перевод Максим Саликов .

Post Views: 7 970

Мы рассказывали о том, как можно с помощью движка Unreal Engine создать свою игру на Android. В этой статье мы рассмотрим другой не менее популярный движок для разработки игр — Unity.

Unity является очень известным движком среди инди-разработчиков. По сути, это кроссплатформенный движок, который позволяет разрабатывать 3D — и 2D -игры. Особенностью, которая выделяет Unity среди остальных движков, является низкий порог вхождения для новичков при наличии богатого инструментария для профессионалов. Кроссплатформенность же позволяет разрабатывать приложения под любую платформу, начиная с десктопных игр и заканчивая мобильными.

Отдельно стоит сказать про систему подписки, поскольку Unity не является полностью бесплатным продуктом. Существует несколько видов подписок:

  • Personal . Бесплатная версия, которая содержит все основные функции движка. Имеет следующее ограничение: доход в год или объём привлечённых средств не должен превышать 100000$ .
  • Plus . За 35 долларов в месяц предоставляются различные отчёты и аналитика, а также возможность изменять заставочный экран, 20% -ая скидка на покупки в Asset Store и различные мелкие преимущества. Имеет следующее ограничение: доход за год или объём привлечённых средств не должен превышать 200000$ .
  • Pro . За 125 долларов в месяц включает в себя все преимущества версии Plus и дополнительно профессиональный сервис и премиум-поддержку. Без ограничений по обороту или объёму средств.
  • Отдельные версии для бизнеса (используются крупными компаниями).

Таким образом, инди-разработчикам с малыми бюджетами должно быть достаточно версии Personal или Plus , в ином случае придётся оформлять подписку Pro . В данной статье воспользуемся бесплатной версией для первого запуска.

Шаг 1. Установка Unity

Для того, чтобы начать установку Unity, нужно перейти на сайт Unity Store , где будет предложено выбрать тип подписки. Как уже говорилось выше, выберем Personal .

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

После запуска установщика, будет предложено выбрать, какие компоненты необходимо установить. Поскольку нам нужно создать приложение под Android, поставим флажок на Android Build Support . Также при желании вместо с Unity можно установить Visual Studio Community 2017 для программирования на C# .

После этого останется только выбрать путь установки и начать инсталляцию Unity.

Шаг 2. Регистрация и настройка Unity

Закончив установку и запустив Unity, нам предлагается войти под своим аккаунтом.

Затем снова будет предложено выбрать подписку, всё также остановимся на Personal. В этом случае нужно будет подтвердить, что годовой доход компании составляет менее 100000$, либо что Unity используется в целях обучения.

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

Шаг 3. Создание нового проекта

Настроив Unity, мы попадаем на экран выбора\создания проекта. Здесь нужно нажать New , чтобы создать свой новый проект.

После этого в появившемся окне предлагается ввести название проекта и директорию, где он будет расположен. Также не забудьте поставить флажок на 3D , чтобы использовать редактор в 3D-режиме.

Закончив с этим, нажмите Create project , чтобы создать проект. После этого откроется окно редактора с заранее сгенерированной сценой.

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

Чтобы открыть Asset Store, нужно в меню Window выбрать Asset Store (комбинация клавиш Ctrl-9 ).

Откроется окно магазина. Введём в строке поиска «flappy bird style example game » и откроем бесплатный пример, который мы будем использовать в своём проекте.

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

Согласившись на импорт, вы увидите окно, в котором нужно выбрать, какие компоненты импортировать. Выбираем все и нажимаем Import .

После завершения импорта в обозревателе проекта вы увидите новые файлы. Это и есть файлы игры. Чтобы открыть сцену в редакторе, раскройте Flappy Bird Style Scenes и дважды кликните по Main .

В результате в окне 3D-редактора появится сцена игры.

Вы можете проверить, как игра работает, прямо в Unity, нажав на кнопку Play над окном редактора.

Шаг 4. Настройка инструментов Android

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

Для того, чтобы собрать получившуюся игру на Android, нужно установить следующие инструменты:

  • Java Development Kit (JDK). Скачать его можно с сайта Java . Перейдя по ссылке, вы увидите на самом верху Java Platform (JDK) , кликните по Download рядом с надписью, затем выберите вашу операционную систему и начните скачивание. После этого просто следуйте инструкциям инсталлятора.
  • Android SDK . Самым простым способом установить актуальную версию является скачивание Android Studio, с которым этот SDK поставляется. Для этого нужно перейти на сайт Android Studio и нажать Download Android Studio . Инсталлятор Android Studio установить базовые компоненты Android SDK, необходимые для разработки на Android.

Шаг 5. Подготовка проекта для запуска

Для начала, необходимо изменить платформу разработки на Android. Для этого в Unity откройте меню File и выберите Build Settings.

В появившемся окне нужно выбрать Android и затем нажать Switch platform .

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

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

Примечание: Имя пакета — это уникальный идентификатор приложения, он пишется в стиле обратного DNS в формате com.CompanyName.ProductName . После публикации приложения в Google Play имя пакета уже нельзя будет изменить.

Для этого перейдём в меню Edit и выберем Project Settings — Player .

В правой части Unity откроется окно с множеством различных настроек, таких как версия приложения, целевой и минимальный SDK, выбор иконки и т.д. Здесь нам нужно в блоке Other Settings найти Identification и задать имя пакета в поле Package Name . При желании можно также изменить и другие параметры.

Теперь осталось только указать путь до Android SDK и JDK. Для этого перейдём в меню и выберем Edit — Preferences .

В появившемся окне нужно перейти в External Tools и в полях SDK и JDK указать соответствующие пути, после чего закрыть окно.

Шаг 6. Сборка и запуск приложения

Настало время собрать своё первое приложение на Unity. Для этого нужно в меню выбрать File — Build Settings . Откроется окно, в нём нужно будет добавить сцену, которую нужно собрать. Поскольку у нас эта сцена уже открыта в редакторе, достаточно просто нажать Add Open Scenes , чтобы добавить её в сборку, после добавления вы увидите её в списке сцен.

Осталось только нажать Build , после чего Unity приступит к сборке приложения. Перед этим вам может быть предложено выбрать папку, куда будут сохраняться собранные файлы приложений, а также имя APK-файла.

Примечание: на данный момент, если у вас в Android SDK установлена альфа-версия Build-Tools (версия 28.0.0-rc1 ), при сборке Gradle выдаст ошибку. Чтобы это исправить, просто удалите из Android SDK эту версию.

В результате в папке, которую вы указали, появится собранный APK-файл, готовый к установке на эмуляторе или на реальном устройстве.

Посмотрим, что находится внутри собранного APK. Для этого воспользуемся утилитой APK Analyzer , которая входит в состав Android Studio,

Размер APK-файла в несжатом виде составляет 21,1 MB , в сжатом же 20,9 MB . Как можно увидеть из графика, большую часть объёма занимают сторонние библиотеки, добавленные Unity. Затем в assets расположены все ресурсы, которые используются в собранной сцене. Файл classes.dex содержит всего 89 классов и 479 методов.

Кроме того, если заглянуть в AndroidManifest.xml , приложение состоит из одной активности.

Заключение

На этом всё. В этой статье мы научились устанавливать и настраивать Unity, а также собрали своё первое приложение на Android.

Статьи по теме: