Единство — Введение

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

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

В этой серии мы будем —

• Научиться использовать различные основы Unity
• Понимание того, как все работает в двигателе
• Понимание основных концепций игрового дизайна
• Создание и создание реальных образцов игр
• Изучение, как развернуть ваши проекты на рынке

Давайте теперь начнем.

Unity — Установка и настройка

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

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

• Выберите свой Unity + Download.

Выберите свой Unity + Download.

На следующей странице нажмите кнопку « Попробовать» под « Личные» . Это бесплатная версия Unity, которая содержит все основные функции. Поскольку мы начинаем эту серию, лучше узнать, как использовать движок, прежде чем рассматривать возможность покупки в Plus или Pro .

На следующей странице прокрутите вниз и нажмите, чтобы подтвердить, что вы или ваша компания зарабатываете не более 100 000 долларов США годового дохода. Если вы это сделаете, вы не сможете попробовать Unity Free, хотя вы можете подписаться на бесплатную 30-дневную пробную версию Pro.

Далее нажмите на нужную платформу для установки Unity. В этой серии мы будем иметь дело с версией движка для Windows . Также возможно установить Unity на Ubuntu и некоторые дополнительные системы Linux, смотрите здесь для получения дополнительной информации.

Также настоятельно рекомендуется установить последнюю версию Visual Studio , которая предоставляет множество полезных инструментов поверх стандартной IDE MonoDevelop, которая поставляется с Unity.

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

Здесь выберите компоненты, которые вам понадобятся. Для этой серии мы хотим установить компоненты, которые вы видите на изображении. Этот выбор включает в себя сам движок, документацию для движка, IDE; создавать инструменты для Android и набор ресурсов, которые вы можете добавить в свой проект позже.

Нажмите «Далее», следуйте инструкциям и опциям, и пусть Unity загружается и устанавливается на ваш компьютер.

Откройте Unity, и на следующем уроке мы создадим наш первый проект.

Создание вашего первого проекта

Unity одинаково подходит как для 2D, так и для 3D игр. Все игры, сделанные в Unity, начинаются как Проекты с загрузочного экрана.

Откройте вашу недавно установленную копию Unity; появится экран, как показано ниже —

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

В правом верхнем углу окна вы увидите иконку New, как показано выше. После нажатия на значок вы увидите экран «Настройка проекта».

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

А пока давайте назовем наш первый проект «Hello World!» И переведем его в режим 2D .

Нажмите « Создать проект» и позвольте Unity настроить основные файлы вашего проекта. Это может занять некоторое время в зависимости от скорости вашего компьютера, предварительно добавленных ресурсов и типа проекта.

Знание двигателя

Как только ваш новый проект создан и Unity открывается, появляется следующий экран —

Давайте посмотрим, что видно в этом окне. В настоящее время мы имеем дело с четырьмя основными регионами —

Это окно, где мы будем строить наши сцены . Сцены — это уровни, на которых происходит все в вашей игре. Если вы нажмете на маленькую вкладку « Игра », вы увидите окно предварительного просмотра того, как игра выглядит для игрока. На данный момент это должен быть простой синий фон.

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

Это окно — Иерархия Сцены . Это место, где перечислены все объекты в текущей открытой сцене, а также их иерархия родитель-потомок. Мы добавим объекты в этот список в ближайшее время.

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

На следующем уроке мы обсудим рабочий процесс и работу игры в Unity.

Как работает Unity?

В Unity весь игровой процесс происходит в сценах . Сцены — это уровни, на которых имеют место все аспекты вашей игры, такие как игровые уровни, титульный экран, меню и вырезанные сцены.

По умолчанию, новая сцена в Unity будет иметь объект Camera в сцене, называемой основной камерой . Можно добавить несколько камер к сцене, но пока мы будем иметь дело только с основной камерой.

Основная камера отображает все, что видит или «снимает» в определенном регионе, называемом окном просмотра . Все, что попадает в этот регион, становится видимым для игрока.

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

Сама сцена состоит из объектов , называемых GameObjects . GameObjects может быть чем угодно, от модели игрока до графического интерфейса на экране, от кнопок и врагов до невидимых «менеджеров», таких как источники звука.

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

На самом деле, мы можем исследовать это прямо сейчас. Нажмите на основную камеру в иерархии сцен и посмотрите на инспектора . Теперь он не будет пустым; вместо этого в нем будет ряд «модулей».

Наиболее важным компонентом для любого GameObject является его компонент Transform . Любой объект, который существует в сцене, будет иметь трансформацию , которая определяет его положение, вращение и масштаб относительно игрового мира или его родителя, если таковой имеется.

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

Давайте теперь рассмотрим несколько примеров компонентов —

• Renderer — отвечает за рендеринг и отображение объектов.

• Коллайдер — определение физических границ столкновения для объектов.

• Rigidbody — Дает объект физические свойства в реальном времени, такие как вес и гравитация.

• Источник звука — предоставляет свойства объекта для воспроизведения и сохранения звука.

• Аудио слушатель — компонент, который фактически «слышит» звук и выводит его на динамики проигрывателя. По умолчанию он существует в основной камере.

• Аниматор — дает объекту доступ к системе анимации.

• Свет — заставляет объект вести себя как источник света с различными эффектами.

Renderer — отвечает за рендеринг и отображение объектов.

Коллайдер — определение физических границ столкновения для объектов.

Rigidbody — Дает объект физические свойства в реальном времени, такие как вес и гравитация.

Источник звука — предоставляет свойства объекта для воспроизведения и сохранения звука.

Аудио слушатель — компонент, который фактически «слышит» звук и выводит его на динамики проигрывателя. По умолчанию он существует в основной камере.

Аниматор — дает объекту доступ к системе анимации.

Свет — заставляет объект вести себя как источник света с различными эффектами.

На этом графике мы можем видеть, как Unity компонует себя через GameObjects в сцены.

На следующем уроке мы создадим наш первый GameObject и погрузимся в сценарии.

Unity — создание спрайтов

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

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

Всякий раз, когда Unity создает новый спрайт, он использует текстуру. Затем эта текстура применяется к свежему GameObject, и к нему прикрепляется компонент Sprite Renderer . Это делает наш gameObject видимым с нашей текстурой, а также дает ему свойства, связанные с тем, как он выглядит на экране.

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

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

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

Давайте рассмотрим следующие моменты при создании спрайта —

• Перетаскивая из внешнего источника в Unity, мы добавляем актив .

• Этот актив является изображением, поэтому он становится текстурой.

• Перетаскивая эту текстуру в иерархию сцены, мы создаем новый GameObject с тем же именем, что и у нашей текстуры, с прикрепленным Sprite Renderer.

• Этот рендерер спрайтов использует эту текстуру для рисования изображения в игре.

Перетаскивая из внешнего источника в Unity, мы добавляем актив .

Этот актив является изображением, поэтому он становится текстурой.

Перетаскивая эту текстуру в иерархию сцены, мы создаем новый GameObject с тем же именем, что и у нашей текстуры, с прикрепленным Sprite Renderer.

Этот рендерер спрайтов использует эту текстуру для рисования изображения в игре.

Теперь мы создали спрайт в нашей сцене.

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

Unity — модифицирование спрайтов

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

Если вы посмотрите в верхнем левом углу интерфейса двигателя, вы найдете панель инструментов, как показано ниже —

Давайте обсудим функции этих кнопок.

• Инструмент « Рука» используется для перемещения по сцене, не затрагивая объекты.

Инструмент « Рука» используется для перемещения по сцене, не затрагивая объекты.

• Далее у нас есть инструмент Move . Это используется для перемещения объектов в игровом мире вокруг.

Далее у нас есть инструмент Move . Это используется для перемещения объектов в игровом мире вокруг.

• В центре у нас есть инструмент Rotate , чтобы вращать объекты вдоль оси Z игрового мира (или родительский объект).

В центре у нас есть инструмент Rotate , чтобы вращать объекты вдоль оси Z игрового мира (или родительский объект).

• Инструмент масштабирования расположен вверх. Этот инструмент позволяет изменять размер (масштаб) объектов вдоль определенных осей.

Инструмент масштабирования расположен вверх. Этот инструмент позволяет изменять размер (масштаб) объектов вдоль определенных осей.

• Наконец, у нас есть инструмент Rect . Этот инструмент ведет себя как комбинация инструментов перемещения и масштабирования , но подвержен потере точности. Это более полезно при расположении элементов пользовательского интерфейса.

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

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

Unity — трансформации и воспитание объектов

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

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

Свойства поворота определяют величину поворота (в градусах), в котором объект вращается вокруг этой оси относительно игрового мира или родительского объекта.

Масштаб объекта определяет, насколько он велик по сравнению с его исходным или собственным размером. Например, возьмем квадрат размером 2х2. Если этот квадрат масштабируется по оси X на 3, а по оси Y на 2, у нас будет квадрат размером 6×4.

В нашем следующем разделе мы обсудим, что такое Object Parenting .

Что такое Воспитание Объектов?

В Unity объекты следуют иерархической системе. Используя эту систему, GameObjects могут стать «родителями» других GameObjects.

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

Например, объект без родителей, размещенный в (10, 0 и 0), будет находиться на расстоянии 10 единиц от центра игрового мира.

Однако gameObject с родителем, размещенным в (10, 0, 0), будет считать текущую позицию родителя центром.

GameObjects можно родить, просто перетаскивая их на нужного родителя. «Дочерний» объект изображен в списке объектов с небольшим отступом и стрелкой рядом с родительским объектом.

Воспитание GameObjects имеет ряд применений. Например, все различные части танка могут быть отдельными GameObjects, объединенными в один GameObject с именем «tank». Таким образом, когда этот «танковый» родительский объект GameObject перемещается, все части перемещаются вместе с ним, потому что их положение постоянно обновляется в соответствии с их родителем.

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

Единство — Внутренние активы

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

Несколько важных примеров внутренних активов, как показано ниже —

• Сцены — Они действуют как «уровни».

• Анимации — они содержат данные для анимации gameObject.

• Материалы — определяют, как освещение влияет на внешний вид объекта.

• Скрипты — код, который будет написан для игровых объектов.

• Prefabs — они служат «чертежами» для объектов GameObject, поэтому их можно создавать во время выполнения.

Сцены — Они действуют как «уровни».

Анимации — они содержат данные для анимации gameObject.

Материалы — определяют, как освещение влияет на внешний вид объекта.

Скрипты — код, который будет написан для игровых объектов.

Prefabs — они служат «чертежами» для объектов GameObject, поэтому их можно создавать во время выполнения.

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

Чтобы создать внутренний актив, щелкните правой кнопкой мыши папку «Активы» и перейдите к « Создать» .

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

Прокрутите выбор Sprites и нажмите на треугольник .

Повторите процесс для Square , и у вас должно быть два новых графических актива.

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

Unity — сохранение и загрузка сцен

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

Все в Unity происходит в сценах. Так же как сохранение и загрузка; Вы должны сохранить свою текущую работу как сцену (расширение .unity) в своих активах.

Давайте попробуем это. Если мы нажмем Ctrl + S и дадим имя нашей сцене, нам будет представлен новый актив в нашем регионе Активы. Это файл сцены.

Теперь давайте попробуем создать новую сцену. Для этого щелкните правой кнопкой мыши на Активы и выберите Создать → Сцена. Дайте вашей новой сцене имя и нажмите Enter.

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

Ваш первый сценарий

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

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

Сценарии в Unity выполняются либо в C #, либо в реализации JavaScript в Unity, известной как UnityScript (однако, с циклом 2018 года, UnityScript сейчас начинает фазу устаревания, поэтому рекомендуется его не использовать). Для целей этой серии мы будем использовать C #.

Чтобы создать новый скрипт, щелкните правой кнопкой мыши в ваших активах и перейдите к Create → C # Script . Вы также можете использовать вкладку Активы в верхней панели движка.

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

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class NewBehaviourScript : MonoBehaviour {
   // Use this for initialization
   void Start() { 
   }
   // Update is called once per frame
   void Update() {

   }
}

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

По мере продолжения у нас есть два закрытых сценария, которые не имеют никаких типов возврата, а именно методы Start и Update . Метод Start запускается один раз для первого фрейма, на котором активен gameObject, в котором он используется.

Метод Update запускает каждый кадр игры после метода Start. Обычно игры в Unity работают со скоростью 60 FPS или кадров в секунду, что означает, что метод Update вызывается 60 раз в секунду, когда объект активен.

Сценарии Unity позволяют вам воспользоваться всеми преимуществами класса MonoBehaviour, а также основными функциями C #, такими как универсальные коллекции, лямбда-выражения и синтаксический анализ XML. На следующем уроке мы напишем наш первый код!

Unity — базовые скрипты движения

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

Помните, что у каждого GameObject есть по крайней мере один компонент — Transform . Что особенного, так это то, что Transform для gameObject также отображается как переменная в сценариях Unity, поэтому мы можем изменить его с помощью кода. Это не ограничивается преобразованием; все компоненты в Unity имеют свойства, которые доступны через переменные в сценариях.

Давайте начнем с нашего сценария движения. Создайте новый сценарий и назовите его «Движение».

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

Давайте создадим общедоступную переменную типа float с именем speed . Обнародование переменной в Unity имеет большое преимущество —

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

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

public class Movement : MonoBehaviour {
   public float speed;
}

Если мы сохраним этот скрипт, не затрагивая другие методы, он должен скомпилироваться в Unity.

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

Затем перетащите сценарий из активов в GameObject. Если вы делаете это правильно, это то, что вы должны увидеть в свойствах GameObject —

Поскольку значение скорости является регулируемым и не требует постоянного изменения кода, мы можем использовать метод update () вместо start ().

Давайте теперь рассмотрим цели для метода обновления —

• Проверьте пользовательский ввод.

• Если есть пользовательский ввод, прочитайте инструкции по вводу.

• Измените значения положения преобразования объекта в зависимости от его скорости и направления. Для этого мы добавим следующий код —

Проверьте пользовательский ввод.

Если есть пользовательский ввод, прочитайте инструкции по вводу.

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

void Update() {
   float h = Input.GetAxisRaw(“Horizontal”);
   float v = Input.GetAxisRaw(“Vertical”);
   
   gameObject.transform.position = new Vector2 (transform.position.x + (h * speed), 
      transform.position.y + (v * speed));

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

Прежде всего, мы создаем переменную с плавающей запятой с именем h (для горизонтали), и ее значение задается методом Input.GetAxisRaw . Этот метод возвращает -1, 0 или 1 в зависимости от того, какую клавишу игрок нажал на стрелки вверх / вниз / влево / вправо.

Класс Input отвечает за получение ввода от пользователя в виде нажатия клавиш, ввода мышью, ввода с контроллера и так далее. Метод GetAxisRaw немного сложнее для понимания, поэтому мы вернемся к этому позже.

Затем мы обновляем позицию нашего gameObject на новую позицию, определенную созданием нового Vector2 . Vector2 принимает 2 параметра, которые являются его значениями x и y соответственно. Для значения x мы предоставляем сумму текущей позиции объекта и его скорости , эффективно добавляя некоторую величину в каждом кадре, когда клавиша нажимается на его позицию.

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

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

Теперь нажмите Play и увидите свою первую маленькую игру в действии!

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

На следующем уроке мы узнаем о твердых телах и столкновениях.

Единство — понимание столкновений

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

Все в вашей игре — GameObject. Даже отдельные плитки, которые составляют ваш уровень, сами по себе являются объектами GameObject.

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

Мы продолжим и добавим простую «стену», с которой может столкнуться наш персонаж. Для этого создайте еще один спрайт и увеличьте его, используя инструмент Rect. Мы также дадим ему красный цвет через свойство Color в компоненте Sprite Renderer.

Теперь перейдите к Add Component в Инспекторе и введите «Box Collider 2D». Нажмите на первый компонент, который появляется, и должен появиться новый компонент.

Вы увидите ярко-зеленую линию по периметру вашего GameObject. Это граница столкновения . Это то, что определяет фактическую форму встречных объектов.

Повторите то же самое с нашим подвижным GameObject.

Конечно, коллизии в Unity не ограничиваются просто боксами. Они могут иметь различные формы и размеры и не обязательно являются точными копиями параметров объекта.

Они также могут принимать многоугольные формы.

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

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

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

Единство — твердые тела и физика

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

Для этого нам необходимо понять, что такое твердые тела . Твердые тела — это компоненты, которые позволяют GameObject реагировать на физику в реальном времени . Это включает в себя реакции на силы и гравитацию, массу, сопротивление и импульс.

Вы можете прикрепить Rigidbody к своему GameObject, просто нажав Add Component и введя Rigidbody2D в поле поиска.

Нажав на Rigidbody2D, вы прикрепите компонент к вашему GameObject. Теперь, когда он прикреплен, вы заметите, что открылось много новых полей.

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

Теперь, игра в игру не будет показывать никакой видимой разницы, потому что GameObject пока не имеет ничего общего с его физическим компонентом.

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

public class Movement : MonoBehaviour {
   public float speed;
   public Rigidbody2D body;
   // Update is called once per frame
   void Update() {
      float h = Input.GetAxisRaw(“Horizontal”);
      float v = Input.GetAxisRaw(“Vertical”);
      body.velocity = new Vector2(h * speed, v * speed);
   }
}

Мы можем видеть, что мы создаем ссылку на Rigidbody2D в объявлениях, и наш код обновления работает с этой ссылкой вместо преобразования объекта. Это означает, что Rigidbody получил ответственность за перемещение.

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

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

Установите более высокое значение скорости, около 5, и играйте в игру.

Ваши столкновения теперь будут работать правильно!

Unity — Пользовательские границы столкновений

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

Давайте начнем с нашего Box Collider. Box Collider (2D) имеет 4 регулируемые стороны и имеет форму прямоугольника. В компоненте коллайдера, нажмите на это поле —

На коллайдере вы увидите 4 «ручки». Вы можете перетащить эти ручки вокруг, чтобы отрегулировать их размеры.

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

Для более сложных форм Unity попытается создать простейшую, но сложнейшую форму коллайдера. Для этого вам нужно использовать Polygon Collider 2D .

Попробуйте нажать на кнопку «Изменить коллайдер» и поэкспериментируйте с настройкой коллайдеров.

Понимание Prefabs и Instantiation

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

Давайте сначала разберемся, что такое сборные . Сборные считаются важными для понимания того, как работает Instantiation в Unity.

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

Чтобы создать префаб, вам просто нужно перетащить нужный GameObject из вашей иерархии сцены в проект Assets .

Теперь, чтобы создать экземпляр GameObject, мы вызываем метод Instantiate () в нашем скрипте. Этот метод, определенный в MonoBehaviour , принимает GameObject в качестве параметра, поэтому он знает, какой GameObject создать / продублировать. Он также имеет различные переопределения для изменения преобразования нового экземпляра объекта, а также для родительских функций.

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

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

Здесь мы используем метод GetKeyDown класса Input, чтобы проверить, нажимал ли игрок определенную кнопку во время последнего кадра. Поскольку мы хотим, чтобы он продолжал проверять, мы помещаем его в обновление , которое выполняется 60 раз в секунду. Метод GetKeyDown возвращает true, если в этом кадре нажата клавиша, указанная в перечислении KeyCode (в котором перечислены все возможные клавиши на стандартной клавиатуре).

public class Instantiator : MonoBehaviour {
   public GameObject Hexagon;
   // Update is called once per frame
   void Update () {
      if (Input.GetKeyDown(KeyCode.Space)) {
         Instantiate(Hexagon);
      }
   }
}

Публичное объявление GameObject вверху создает слот, похожий на тот, который мы сделали для Rigidbody2D в наших предыдущих уроках. Однако этот слот принимает только префабы (во время редактирования ) и gameObjects (во время выполнения).

Сохраните скрипт и дайте ему скомпилироваться. Как только это будет сделано, создайте новый пустой GameObject, перейдя в контекстное меню иерархии объектов и выбрав Create Empty .

Назовите этот объект как-нибудь узнаваемым, например, объект Instatiator, и присоедините к нему наш новый скрипт. В слот, который отображается для GameObject, перетащите созданный нами сборный дом.

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

На нашем следующем уроке мы поймем концепцию разрушения объекта.

Unity — уничтожение GameObject

Уничтожение GameObjects так же важно, как и создание экземпляров. В этой главе мы узнаем, как уничтожать объекты GameObject.

К счастью, уничтожить GameObjects так же просто, как и создать их. Вам просто нужна ссылка на объект, который нужно уничтожить, и вызовите метод Destroy () с этой ссылкой в ​​качестве параметра.

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

Давайте создадим новый скрипт под названием HexagonDestroyer и откроем его в Visual Studio. Мы начнем с создания публичной переменной KeyCode . KeyCode используется для указания клавиши на стандартной клавиатуре, и класс Input в своих методах использует ее. Делая эту переменную общедоступной, как мы делали это ранее с Rigidbody и Prefabs, мы можем сделать ее доступной через редактор. Когда переменная становится общедоступной, нам не нужно жестко кодировать значения, такие как «KeyCode.A», в код. Код можно сделать гибким, используя столько объектов, сколько мы хотим.

public class HexagonDestroyer : MonoBehaviour {
   
   public KeyCode keyToDestroy;

   // Update is called once per frame
   void Update () {
      
      if (Input.GetKeyDown(keyToDestroy)) {
         Destroy (gameObject);
      }
   }
}

Посмотрите, как мы использовали переменную с именем «gameObject» (small g, прописная буква O) в методе. Эта новая переменная gameObject (типа GameObject ) используется для ссылки на gameObject, к которому прикреплен этот скрипт. Если вы присоедините этот скрипт к нескольким объектам, они будут реагировать одинаково, когда эта переменная задействована.

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

• GameObject с большой буквы G и O — это класс, который охватывает все объекты GameObject и предоставляет стандартные методы, такие как Instantiate, Destroy и методы для извлечения компонентов.

• gameObject с маленьким g и заглавной буквой O — это конкретный экземпляр GameObject, используемый для ссылки на gameObject, к которому в данный момент прикреплен этот скрипт.

GameObject с большой буквы G и O — это класс, который охватывает все объекты GameObject и предоставляет стандартные методы, такие как Instantiate, Destroy и методы для извлечения компонентов.

gameObject с маленьким g и заглавной буквой O — это конкретный экземпляр GameObject, используемый для ссылки на gameObject, к которому в данный момент прикреплен этот скрипт.

Давайте теперь скомпилируем наш код и вернемся к Unity.

Теперь мы создадим новый шестиугольный спрайт и прикрепим к нему наш скрипт. Затем щелкните правой кнопкой мыши gameObject в иерархии и выберите Duplicate . Новый спрайт создается в иерархии; Вы должны использовать инструмент Переместить , чтобы переместить его. Повторите шаги, чтобы создать похожие шестиугольники.

Нажмите на каждый из шестиугольников и посмотрите на их компоненты скрипта. Теперь вы можете установить отдельные клавиши так, чтобы GameObject разрушал себя при нажатии этой клавиши. Например, давайте создадим 5 шестиугольников и настроим их на уничтожение при нажатии клавиш A, S, D, F и G.

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

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

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

Единство — сопрограммы

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

IEnumerator MyCoroutineMethod() {
   // Your code here…
   
   yield return null;
}

Как правило, если вы вызываете функцию в Unity (или, на самом деле, C #), функция запускается от начала до конца. Это то, что вы считаете «нормальным» поведением в том, что касается вашего кода. Однако иногда мы хотим намеренно замедлять функцию или заставлять ее ждать дольше, чем она длится доли секунды. Сопрограмма способна именно на это: сопрограмма — это функция, которая способна ожидать и синхронизировать свой процесс, а также полностью останавливать его.

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

Для начала мы создаем спрайт. Затем создайте новый скрипт и назовите его ColorChanger . В этом скрипте мы получаем ссылку на Sprite Renderer спрайта. Однако мы будем использовать другой способ получения компонента. Вместо того чтобы перетаскивать компонент в слот, как мы делали до сих пор, мы попросим код определить сам компонент.

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

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

private SpriteRenderer sr;

public Color color1;
public Color color2;

void Start () {
   sr = GetComponent<SpriteRenderer>();
   StartCoroutine(ChangeColor());
}

IEnumerator ChangeColor() {
   
   while (true) {
      
      if (sr.color == color1)
         sr.color = color2;
      
      else
         sr.color = color1;
      
      yield return new WaitForSeconds(3);
   }
}

Теперь мы перехватим нашу функцию сопрограммы в цикле while.

Чтобы создать сопрограмму в C #, мы просто создаем метод, который возвращает IEnumerator . Также необходимо заявление о доходности . Отчет о доходности является особенным; это то, что на самом деле говорит Unity приостановить выполнение сценария и перейти к следующему кадру.

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

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

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

Единство — Консоль

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

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

• ошибки
• Предупреждения
• Сообщения

ошибки

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

Предупреждения

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

Сообщения

Сообщения — это выходные данные, которые что-то передают пользователю; они обычно не выделяют проблемы.

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

Вы можете найти Консоль на вкладке с надписью над областью Активы.

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

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

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

void Update() {
   if (Input.GetKeyDown(KeyCode.Space))
      Debug.Log(“Space key was pressed!”);
}

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

Примечание. Обратите внимание, что сообщение отображается внизу редактора.

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

Аналогично, вы также можете выводить предупреждения, используя метод LogWarning, а ошибки — методом LogErro r. Они окажутся полезными для тестирования небольших фрагментов кода без необходимости их реализации, как вы увидите позже.

Unity — Введение в Аудио

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

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

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

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

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

Аудио Компоненты

В этом разделе мы узнаем о 3 основных компонентах, связанных со звуком в Unity.

AudioSource

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

AudioClip — это просто звуковой файл, который загружается в AudioSource. Это может быть любой стандартный аудиофайл, например .mp3, .wav и т. Д. AudioClip также является компонентом внутри себя.

AudioListener

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

Аудио Фильтры

Выход AudioSource или прием AudioListener могут быть изменены с помощью Audio Filters. Это конкретные компоненты, которые могут изменять реверберацию, хорус, фильтрацию и т. Д. Каждый конкретный фильтр представляет собой свой собственный компонент с доступными значениями для настройки его звучания.

Воспроизведение звука

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

Теперь давайте подключим аудиоисточник к этому спрайту.

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

http://www.orangefreesounds.com/ding-sfx/

Загрузите звуковой эффект и перетащите его в Активы.

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

После того, как вы перетащите аудиоклип из Активов непосредственно в слот Аудиоклипа в Аудиоисточнике нашего спрайта, не забудьте отменить выбор «Воспроизвести при пробуждении» в свойствах Аудиоисточника; если вы этого не сделаете, звук начнет звучать в момент начала игры.

Теперь давайте перейдем к нашему коду. Создайте новый скрипт под названием «BellSound» и откройте его.

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

public class BellSound : MonoBehaviour {
   AudioSource mySource;
   // Use this for initialization
   void Start () {
      mySource = GetComponent<AudioSource>();
}

Теперь давайте настроим метод обнаружения объекта, по которому щелкают. MonoBehaviour дает нам именно тот метод, который нам нужен, с именем OnMouseDown. Метод вызывается всякий раз, когда мышь щелкает в диапазоне коллайдера этого gameObject.

Поскольку мы еще не прикрепили коллайдер к нашей кнопке, давайте сделаем это сейчас.

Нам не понадобится Rigidbody для этого; нам также не нужен доступ к этому коллайдеру по коду. Это просто должно быть там, чтобы метод работал.

Давайте проверим метод и посмотрим, работает ли он. Напишите следующий код в своем скрипте и прикрепите его к кнопке.

void OnMouseDown() {
   Debug.Log(“Clicked!”);
}

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

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

void OnMouseDown() {
   mySource.Play();
}

Сохраните ваш скрипт и запустите его в игре. Нажмите на кнопку, и вы должны услышать звук!

Примечание. Подумайте о создании кнопки, которая увеличивается по высоте при каждом нажатии на нее. Используйте mySource.pitch и счетчик и посмотрите, сможете ли вы это выяснить.)

Unity — начиная с пользовательского интерфейса

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

Рабочий процесс для разработки пользовательского интерфейса в Unity следует немного по другому пути, чем тот, который мы проходили до сих пор. Для начала, элементы пользовательского интерфейса не являются стандартными объектами GameObject и не могут использоваться как таковые. Элементы пользовательского интерфейса разработаны по-разному; кнопка меню, которая выглядит правильно в разрешении 4: 3, может выглядеть растянутой или искаженной в разрешении 16: 9, если не настроена правильно.

Элементы пользовательского интерфейса в Unity не размещаются непосредственно на сцене. Они всегда помещаются как дети специального GameObject, называемого Canvas . Canvas похож на «чертежный лист» для пользовательского интерфейса на сцене, где будут отображаться все элементы пользовательского интерфейса. Создание элемента пользовательского интерфейса из контекстного меню « Создать» без существующего Canvas автоматически создаст его.

Давайте теперь посмотрим на Canvas GameObject, чтобы узнать о дополнительных новых компонентах —

Похоже, что Rect Transform в верхней части имеет много новых свойств, которых нет в стандартном Transform GameObject.

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

Мы можем видеть некоторые стандартные свойства прямоугольника, такие как Высота и Ширина, а также два новых свойства, называемых Якорями . Якоря — это точки, на которые другие сущности могут «зацепиться» в Canvas. Это означает, что если элемент пользовательского интерфейса (скажем, кнопка) привязан к холсту справа, изменение размера холста гарантирует, что кнопка всегда находится относительно справа от холста.

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

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

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

У нас есть три варианта в раскрывающемся списке. Давайте узнаем об опциях в наших последующих разделах.

Пространство экрана — Наложение

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

Пространство экрана — камера

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

Мир Космоса

В режиме World Space элементы пользовательского интерфейса ведут себя так, как если бы они были обычными объектами GameObject, помещенными в мир. Однако они похожи на спрайты, поэтому они обычно используются как часть игрового мира, а не для игрока, как игровые мониторы и дисплеи. По этой причине вы можете напрямую изменять значения Canvas RectTransform в этом режиме.

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

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

Единство — Кнопка

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

Давайте начнем с кнопки . Чтобы вставить кнопку, щелкните правой кнопкой мыши в иерархии сцен и выберите « Создать» → «Пользовательский интерфейс» → «Кнопка» . Если у вас нет существующего Canvas и EventSystem, Unity автоматически создаст его и поместит кнопку внутри Canvas.

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

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

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

Давайте создадим новый скрипт и назовем его ButtonBehaviour .

public class ButtonBehaviour : MonoBehaviour {
   int n;
   public void OnButtonPress(){
      n++;
      Debug.Log("Button clicked " + n + " times.");
   }
}

Мы сделали простой метод, который регистрирует, сколько раз мы нажали кнопку.

Примечание. Этот метод должен быть общедоступным; иначе это не будет замечено функциональностью кнопки.

Давайте создадим пустой GameObject и прикрепим к нему этот скрипт. Мы делаем это, потому что кнопка не будет ничего делать сама по себе; он вызывает только указанный метод в своем сценарии.

Теперь перейдите в свойства Button и найдите свойство OnClick () .

Нажмите значок + на нижней вкладке, и новая запись должна появиться в списке.

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

Перетащите пустой GameObject, который содержит созданный нами скрипт ButtonManager , в слот None (Object) .

Перейдите в раскрывающийся список « Нет функции» и найдите наш метод OnButtonPress . (Помните, что он может быть назван как угодно, OnButtonPress — это просто стандартное соглашение об именах.) Вы должны найти его в разделе ButtonBehaviour .

Если вы играете в игру сейчас, вы можете проверить кнопку и, конечно же, консоль распечатает, сколько раз вы нажали кнопку.

Unity — элемент текста

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

Для нашей цели ванильный элемент Text более чем достаточен для начала.

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

Чтобы вставить текстовый элемент пользовательского интерфейса, перейдите к иерархии сцен, выберите « Создать» → «Пользовательский интерфейс» → «Текст» .

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

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

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

Доступ к элементу Text также возможен через скрипты; это то, где важность динамического пользовательского интерфейса вступает в силу.

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

using UnityEngine;
using UnityEngine.UI;
public class ButtonBehaviour : MonoBehaviour {
   int n;
   public Text myText;
   public void OnButtonPress(){
      n++;
      myText.text = "Button clicked " + n + " times.";
   }
}

Первое изменение, которое мы сделали, — добавление новой ссылки на пространство имен. Эта ссылка используется для работы с компонентами пользовательского интерфейса Unity, поэтому мы добавляем строку using UnityEngine.UI .

Затем мы создаем общедоступную переменную Text, куда мы можем перетащить наш элемент Text UI.

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

Если мы сохраним наш скрипт, мы теперь увидим новый слот для элемента Text UI в нашем ButtonManager. Просто перетащите элемент gameObject, содержащий этот элемент Text, в слот и нажмите кнопку Play.

Единство — Слайдер

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

Чтобы создать слайдер, выберите «Создать» → «Интерфейс» → «Слайдер». Новый элемент Slider должен появиться на вашей сцене.

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

Давайте попробуем сделать слайдер громкости из этого слайдера. Для этого откройте скрипт ButtonBehaviour (вы можете переименовать ButtonManager GameObject, поскольку он, безусловно, делает больше, чем просто управление кнопкой сейчас) и добавить ссылку на Slider. Мы также немного изменим код.

public class ButtonBehaviour : MonoBehaviour {
   int n;
   public Text myText;
   public Slider mySlider;
   void Update() {
      myText.text = "Current Volume: " + mySlider.value;
   }
}

Узнайте, как мы используем метод Update, чтобы постоянно обновлять значение myText.text.

В свойствах слайдера давайте отметим поле «Целые числа» и установим максимальное значение равным 100.

Мы установим цвет текста через его свойства для более видимого цвета.

Проделаем ту же процедуру перетаскивания игрового объекта Slider на новый слот и нажмем кнопку play.

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

В нашем следующем разделе мы узнаем об освещении, материалах и шейдерах.

Unity — материалы и шейдеры

В этой главе мы кратко познакомимся с материалами и шейдерами. Чтобы лучше понять, мы создадим новый 3D-проект вместо нашего текущего 2D- проекта . Это поможет нам увидеть различные изменения.

Создав новый проект, перейдите в иерархию и щелкните правой кнопкой мыши и выберите « 3D-объект» → «Куб» . Это создаст новый куб в середине сцены. Вы можете посмотреть вокруг куба, удерживая правую кнопку мыши и перетаскивая мышь в виде сцены. Вы также можете увеличивать и уменьшать масштаб с помощью колеса прокрутки.

Теперь нажмите на куб и посмотрите на его свойства.

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

Что такое материал?

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

Теперь не путайте с именем; Материал не имеет ничего общего с массой, столкновениями или даже физикой в ​​целом. Материал используется для определения того, как освещение влияет на объект с этим материалом.

Давайте попробуем создать наш собственный материал. Щелкните правой кнопкой мыши в области «Активы», перейдите в « Создать» → «Материал» и дайте ему имя, например «Мой материал».

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

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

Что такое шейдер?

Шейдер — это программа, которая определяет, как каждый пиксель отображается на экране. Шейдеры вообще не программируются на C # или даже на языке OOPS. Они запрограммированы на C-подобном языке, называемом GLSL, который может давать прямые инструкции GPU для быстрой обработки.

Единство — система частиц

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

Теперь, частицы — это неоднозначный термин в системе частиц; Частица — это любая отдельная текстура, экземпляр материала или объект, который генерируется системой частиц. Это не обязательно точки, плавающие в пространстве (хотя они могут быть!), И их можно использовать для множества различных сценариев.

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

Чтобы создать систему частиц, либо добавьте компонент Particle System через параметр Add Component, либо перейдите в Иерархию и выберите Create → Effects → Particle System . Это создаст новый GameObject с подключенной системой частиц.

Если вы посмотрите на свойства системы частиц, то увидите, что она состоит из множества модулей . По умолчанию активны только три модуля; Эмиссия, Форма и Рендерер . Другие модули можно активировать, нажав на маленький кружок рядом с их именем.

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

Unity — Использование Asset Store

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

Чтобы использовать Asset Store, вам нужно иметь действительный Unity ID . Если у вас его нет, вы можете создать его на сайте Unity.

Создав Unity ID, нажмите на вкладку « Хранилище активов » в той же строке, что и представление сцены .

После входа в систему вы сможете увидеть свое имя пользователя в правом верхнем углу.

В этом примере мы будем импортировать проект Survival Shooter Tutorial . Для этого мы будем искать его на вкладке и нажимать на ресурс, опубликованный Unity.

Мы нажмем «Загрузить» и дадим его завершить. По завершении кнопка « Загрузить» изменится на « Импорт» ; нажмите на него еще раз, чтобы импортировать новый актив в текущий открытый проект.

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

Появится новое окно со списком всего нового импортированного вами Актива. В зависимости от того, что вы скачали, это может быть один файл, или группа файлов, или целое дерево с иерархиями папок и файлов. По умолчанию Unity будет импортировать все компоненты активов, когда вы нажмете « Импорт» , что нам и нужно. Теперь давайте кликнем на Impor t, чтобы Unity сделала свою работу.

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