Первая сцена в Unity: Интерфейс и базовые объекты

Анатомия редактора: Настройка рабочего пространства и логика окон

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

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

Четыре столпа вашего проекта

Каждое окно в Unity выполняет строго одну функцию в «театральной постановке» вашей игры.

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

2. Окно Hierarchy (Список актеров на сцене) Это текстовый список всего, что прямо сейчас находится на текущем уровне. Главный герой, враги, земля, камера, фоновая музыка — всё это отображается здесь в виде строк. Если объекта нет в Иерархии, его нет в текущей сцене.

3. Окно Scene и Game (Сама сцена и взгляд зрителя) Это визуальное представление вашей игры. Вкладка Scene — это ваш рабочий стол. Здесь вы можете летать камерой, двигать платформы, расставлять врагов мышкой. Это взгляд «из-за кулис». Вкладка Game показывает игру ровно так, как ее увидит игрок через объектив игровой камеры. Вы не можете двигать объекты мышкой во вкладке Game — вы можете только играть.

4. Окно Inspector (Гримерка и досье) Это окно свойств. Оно всегда показывает настройки того объекта, который вы выделили в данный момент. Выделили камеру в Иерархии? Инспектор покажет ее настройки. Выделили картинку в Project? Инспектор покажет ее разрешение.

Главное правило интерфейса Unity: Выбираем объект в Project или Hierarchy $\rightarrow$ настраиваем его свойства в Inspector $\rightarrow$ видим результат в Scene или Game.

Настройка рабочего пространства под 2D

По умолчанию Unity предлагает компоновку (Layout), которая хорошо подходит для 3D-игр, но для разработки 2D пиксель-арт проектов она не всегда идеальна.

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

Для 2D-игр разработчики часто используют подход, при котором окна Scene и Game видны одновременно. Это позволяет вам двигать платформу на сцене и сразу видеть, как это выглядит в финальной игре, не переключая вкладки.

Чтобы не собирать интерфейс вручную, в правом верхнем углу редактора есть выпадающее меню Layout. Попробуйте переключить его с Default на 2 by 3. Вы увидите, как редактор мгновенно перестроится: сцена и игра встанут слева друг над другом, иерархия и проект займут центр, а инспектор останется справа. Это классическая раскладка, с которой удобно начинать путь в 2D-разработке.

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

Иерархия и Сцена: Организация структуры игровых объектов

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

Эта универсальная единица называется GameObject (игровой объект). Сам по себе GameObject — это просто пустой контейнер. У него изначально нет ни картинки, ни физики, ни логики поведения. Его единственное врождённое свойство — это существование в пространстве.

Две стороны одной медали

Чтобы добавить GameObject в проект, достаточно кликнуть правой кнопкой мыши в окне Hierarchy и выбрать Create Empty. В этот момент происходят две вещи одновременно:

1. В списке Hierarchy появляется новая строчка с именем объекта.
2. В пространстве Scene появляется невидимая точка, обозначающая положение этого объекта в мире.

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

Когда объектов становится много, плоский список в Иерархии быстро превращается в хаос. Если ваш 2D-рыцарь состоит из туловища, меча, щита и шлема, держать их как независимые объекты крайне неудобно. Здесь на помощь приходит главный механизм организации в Unity.

Магия вложенности: Parent и Child

Любой GameObject можно поместить внутрь другого. Для этого в окне Hierarchy нужно просто перетащить один объект на другой.

Объект, в который поместили другие, называется Родителем (Parent). Объекты, находящиеся внутри него, называются Потомками (Child) или дочерними объектами. Объект, у которого нет родителя (он лежит в самом корне Иерархии), называется Корневым (Root).

Эта связь — не просто папки для удобства сортировки. Вложенность фундаментально меняет поведение объектов на Сцене. Потомок жестко привязывает свою систему координат к родителю.

Понимание этого правила решает множество проблем при разработке:

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

Пустые объекты как папки

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

Например, вы создаете уровень для 2D-игры. Вы можете создать пустой GameObject, назвать его Environment (Окружение), и перетащить в него все деревья, камни и платформы. Затем создать пустой объект Enemies (Враги) и сложить туда всех монстров.

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

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

Инспектор и компоненты: Как свойства определяют поведение объекта

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

Философия Unity: Объект — это пустой контейнер

В традиционном программировании свойства объекта часто определяются его типом: если мы создаем «Собаку», она умеет лаять, потому что унаследовала это от класса «Животное». Unity использует другой подход — компонентную архитектуру (Entity-Component).

Любой GameObject в Unity — это абсолютно пустой мешок. Его поведение зависит исключительно от того, какие детали (компоненты) вы в него положите.

Положили в мешок компонент, отвечающий за отрисовку картинки — объект стал видимым. Добавили компонент источника звука — объект начал шуметь. Добавили физическое тело — объект упал под действием гравитации. Уберите компонент отрисовки, и объект снова станет невидимым, но продолжит падать и шуметь.

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

Transform: Единственное исключение из правил

Из правила «GameObject — это пустой мешок» есть ровно одно исключение. Вы не можете создать объект, в котором вообще ничего нет.

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

1. Position (Позиция) — где объект находится в пространстве.
2. Rotation (Вращение) — куда он повернут.
3. Scale (Масштаб) — какого он размера.

Без этих данных Сцена просто не смогла бы понять, где отрисовывать объект и как применять к нему правила вложенности (о которых мы говорили ранее). Transform — это якорь объекта в мире игры.

Анатомия окна Inspector

Окно Inspector (Инспектор) — это панель управления содержимым вашего «мешка». Когда вы кликаете на любой объект в Иерархии, Инспектор мгновенно перестраивается, чтобы показать все компоненты, прикрепленные к этому конкретному объекту.

Инспектор всегда читается сверху вниз:

• Шапка объекта. Здесь находится галочка активности (включает/выключает объект целиком), поле имени (которое отображается в Иерархии), а также теги и слои для группировки.
• Блок Transform. Всегда идет первым среди компонентов, так как является базовым.
• Список компонентов. Дальше друг за другом идут блоки остальных компонентов. У каждого компонента есть свое имя, иконка, галочка включения (можно отключить конкретную функцию, не выключая весь объект) и список настраиваемых свойств — переменных.
• Кнопка Add Component. Главный инструмент созидания. Нажав её в самом низу Инспектора, вы открываете каталог всех доступных в Unity деталей.

Практика: Собираем 2D-персонажа

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

Допустим, у нас есть пустой объект Player. В Инспекторе мы видим только шапку и Transform. Чтобы сделать его видимым персонажем, мы нажимаем Add Component и находим Sprite Renderer (Отрисовщик спрайтов).

Как только компонент добавлен, в Инспекторе появляется новый блок свойств. Самое важное из них — поле Sprite. Если мы перетащим туда картинку нашего пиксельного героя из окна Project, пустой объект мгновенно обретет визуальную форму на Сцене.

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

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

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

Система координат и навигация в пространстве Unity

Мы наделили пустышку компонентом Sprite Renderer, и объект стал видимым. Но если мы хотим поставить нашего пиксельного рыцаря ровно на землю, а не бросить его «где-то в пустоте», визуального контроля недостаточно. Компонент Transform требует точных математических значений. Чтобы управлять пространством, нужно понимать, как Unity его измеряет.

Математический холст: Оси X, Y и Z

Пространство в Unity — это классическая декартова система координат. Центр мира — это точка с координатами $(0, 0, 0)$. От неё во все стороны расходятся невидимые линии, по которым выстраивается геометрия уровня.

Даже если вы создаёте 2D-игру и смотрите на сцену плоско, движок Unity всегда остаётся трёхмерным. Пространство опирается на три оси:

• Ось X (Красная) — отвечает за движение влево и вправо. Отрицательные значения — слева от центра, положительные — справа.
• Ось Y (Зелёная) — отвечает за движение вверх и вниз. Это высота вашего объекта.
• Ось Z (Синяя) — отвечает за глубину (вперёд и назад).

В 2D-играх ось Z не используется для перемещения персонажа, но она критически важна для сортировки: объект с $Z = 1$ будет находиться «дальше» от камеры, чем объект с $Z = -1$. Это позволяет выстраивать слои: фон, игровые объекты, передний план.

Что такое «одна единица» в Unity?

Когда в компоненте Transform вы пишете $X = 1$, что это значит? Сантиметр, пиксель, километр?

В Unity используется абстрактная величина — Unity Unit (единица Unity). Встроенная физика движка настроена так, что 1 Unit равен 1 метру реального мира. Однако для 2D пиксель-арта это правило гибкое. Позже мы познакомимся с настройкой Pixels Per Unit (PPU), которая скажет движку, сколько пикселей вашего спрайта должно помещаться в один этот математический метр (квадрат сетки окна Scene).

Глобальные и локальные координаты

Здесь мы возвращаемся к механике вложенности (Parent и Child), которую разобрали ранее. Когда вы смотрите на компонент Transform в окне Inspector, вы видите не абсолютные координаты объекта в мире, а его локальные координаты.

Разница между ними — частая причина ошибок у начинающих разработчиков:

• Глобальные координаты (World Space) — это фактическое положение объекта относительно центра мира $(0, 0, 0)$.
• Локальные координаты (Local Space) — это положение объекта относительно центра его Родителя (Parent).

Если объект является Корневым (Root) и не имеет родителя, его локальные и глобальные координаты совпадают. Но как только объект становится Потомком (Child), его Transform начинает отсчитывать позицию от родителя.

Если Родитель находится в глобальной точке $X = 5$, а Потомок сдвинут внутри него на локальный $X = 2$, то фактическая (глобальная) позиция Потомка в мире будет $5 + 2 = 7$.

Эта логика позволяет создавать сложные механизмы. Например, меч в руке персонажа всегда имеет локальные координаты $(X=0.5, Y=0)$ относительно кисти руки. Куда бы ни побежал персонаж (меняя свои глобальные координаты), меч останется в руке, потому что его локальные координаты неизменны.

Навигация: Как осматривать сцену

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

1. Панорамирование (Pan): Зажмите среднюю кнопку мыши (колёсико) или выберите инструмент Hand Tool (горячая клавиша Q). Курсор превратится в руку, и вы сможете таскать «холст» сцены влево-вправо и вверх-вниз.
2. Масштабирование (Zoom): Крутите колёсико мыши, чтобы приблизиться к объекту или отдалиться от него.
3. Фокусировка (Focus): Самый важный шорткат. Если вы потеряли объект в огромном пустом пространстве, выделите его в окне Hierarchy, наведите курсор на окно Scene и нажмите клавишу F. Камера мгновенно центрируется на выбранном объекте.

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

Создание и трансформация базовых 3D и 2D примитивов

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

Рождение материи: Встроенные примитивы

Вам не обязательно сразу импортировать сложные 3D-модели или нарисованные спрайты, чтобы начать делать игру. Unity содержит набор встроенных простых форм — примитивов. Они идеально подходят для прототипирования (создания чернового наброска уровня), которое в геймдеве называют «блокингом».

Чтобы создать объект, достаточно кликнуть правой кнопкой мыши в пустом месте окна Hierarchy и выбрать нужный раздел:

• Для 3D (3D Object): Cube (Куб), Sphere (Сфера), Capsule (Капсула — часто используется как временная модель игрока), Plane (Плоскость для пола).
• Для 2D (2D Object -> Sprites): Square (Квадрат), Circle (Круг), Capsule (Капсула).

Разница между ними кроется в компонентах. Если вы создадите 3D-куб, Unity добавит на него компоненты для отрисовки трехмерной геометрии (Mesh Filter). Если создадите 2D-квадрат, движок повесит на него уже знакомый нам Sprite Renderer. Но и те, и другие подчиняются общим правилам трансформации.

Визуальная лепка: Инструменты трансформации

В прошлых главах мы выяснили, что за положение объекта отвечает компонент Transform. Вы можете менять числа осей X, Y и Z прямо в окне Inspector. Это полезно для ювелирной точности, но для быстрой расстановки уровня вводить цифры вручную слишком долго.

Для визуальной работы в окне Scene используются инструменты трансформации. При выборе инструмента на выделенном объекте появляется Gizmo (Гизмо) — цветной интерактивный манипулятор.

Инструмент	Горячая клавиша	Как выглядит Gizmo	Зачем нужен
Move	W	Три стрелки (Красная — X, Зеленая — Y, Синяя — Z)	Перемещение объекта вдоль осей. Если потянуть за квадратик между осями, объект будет двигаться сразу в двух плоскостях.
Rotate	E	Три пересекающихся кольца	Вращение. Потянув за кольцо, вы вращаете объект строго вокруг одной оси.
Scale	R	Линии с кубиками на концах	Изменение масштаба. Центральный серый кубик меняет размер пропорционально по всем осям.

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

Особенность 2D: Инструмент Rect Tool

Если вы делаете 3D-игру, инструментов Move, Rotate и Scale вам будет достаточно. Но так как ваша цель — 2D пиксель-арт, вам необходимо познакомиться с четвертым инструментом: Rect Tool (горячая клавиша T).

В 2D-пространстве объекты плоские. Использование обычного Scale (R) для изменения размера спрайта часто приводит к искажению пикселей — они растягиваются и становятся мыльными.

Rect Tool работает иначе. Он обводит 2D-объект плоской прямоугольной рамкой с точками по углам и краям.

• Перетаскивание за центр перемещает объект.
• Перетаскивание за углы — меняет размер рамки.
• Если курсор вынести чуть за пределы угла, инструмент превратится во вращение.

Rect Tool — это универсальный комбайн для 2D, позволяющий делать всё, не переключая инструменты. Позже, когда мы дойдем до создания интерфейсов (UI), этот инструмент станет вашим главным оружием.

Связь пикселей и метров: Pixels Per Unit (PPU)

Здесь мы подходим к важнейшей концепции для любого разработчика 2D-игр.

Вспомним предыдущую главу: сетка в окне Scene размечена в Unity Units (юнитах), где 1 юнит условно равен 1 метру физического пространства. Но спрайты, которые вы рисуете, измеряются в пикселях. Возникает вопрос: если вы перетащите на сцену нарисованного персонажа размером 32x32 пикселя, какого размера в метрах он будет?

Ответ кроется в настройке Pixels Per Unit (PPU) — «Пикселей на Юнит». Эта настройка находится в окне Inspector, когда вы выделяете сам файл картинки в окне Project (до того, как перетащили его на сцену).

Формула связи проста: Размер в юнитах = Размер спрайта в пикселях / PPU

Разберем на примере вашей будущей пиксель-арт игры: Допустим, вы нарисовали главного героя. Его размер в файле — 32 на 32 пикселя.

1. Если PPU картинки равен 100 (значение в Unity по умолчанию), то персонаж займет на сцене 32 / 100 = 0.32 юнита. Он будет крошечным и не совпадет с сеткой координат.
2. Если вы измените PPU на 32, то персонаж займет ровно 32 / 32 = 1 юнит.

Для пиксель-арт игр золотое правило — выбрать одно значение PPU для всего проекта и строго его придерживаться. Если базовый тайл (блок земли) в вашей игре имеет размер 16x16 пикселей, установите PPU равным 16 для всех картинок. Тогда каждый блок земли будет занимать ровно одну клетку (1 юнит) на сцене, и строить уровни станет невероятно легко.

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

Префабы и ресурсы: Основы управления активами проекта

Представьте, что вы расставили на 2D-уровне 100 пиксельных монет. Вы тщательно выверили их позиции, потратили полчаса времени, а затем поняли: спрайт монеты слишком тусклый, и к нему нужно добавить компонент свечения. Менять свойства ста объектов вручную — это путь к выгоранию. Движок предлагает другой подход: превратить монету в единый шаблон, изменение которого мгновенно отразится на всех копиях в игре.

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

Ассеты и Экземпляры: Разделение понятий

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

Ассет (Asset) — это файл в папке вашего проекта. Картинка (спрайт), аудиофайл, скрипт на C# или 3D-модель. Ассеты живут исключительно в окне Project. Сами по себе они ничего не делают в игре, это просто строительный материал.

Экземпляр (Instance) — это конкретный GameObject, созданный на сцене (в окне Hierarchy).

Когда вы берете спрайт 2D-рыцаря из окна Project и перетаскиваете его на сцену, Unity делает две вещи:

1. Создает новый пустой GameObject в Иерархии.
2. Автоматически добавляет к нему компонент Sprite Renderer и вставляет в него ссылку на ваш файл-ассет.

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

Рождение Префаба

Возвращаемся к проблеме 100 монет. Чтобы не настраивать каждую монету отдельно, нам нужен Префаб (Prefab).

Префаб — это сохраненный в виде ассета GameObject со всеми его компонентами, вложенными потомками и настроенными свойствами. Это своеобразный «заводской чертеж».

Создать префаб невероятно просто:

1. Вы собираете идеальный объект на сцене (например, добавляете монете Sprite Renderer, настраиваете PPU, добавляете звук звона).
2. Берете этот готовый GameObject в окне Hierarchy и перетаскиваете его вниз, в окно Project.
3. В Project появляется новый файл с иконкой синего куба. Это и есть ваш Префаб.

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

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

Глобальные изменения: Prefab Mode

Главная сила префаба — централизованное управление. Если вам нужно изменить все 100 монет разом, вы не трогаете их на сцене.

Вы дважды кликаете по файлу префаба в окне Project. Unity откроет Prefab Mode (Режим префаба) — изолированное пространство, где виден только этот шаблон на пустом фоне. Любое изменение, сделанное здесь (замена спрайта, изменение масштаба, добавление нового компонента), после выхода из режима мгновенно применится ко всем 100 монетам на вашей сцене.

Локальные изменения: Переопределения (Overrides)

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

Если вы выделите конкретный экземпляр префаба в Иерархии и поменяете ему цвет в Инспекторе, эта настройка применится только к этому объекту. Это называется Override (Переопределение).

В Инспекторе переопределенное свойство подсвечивается жирным шрифтом и синей линией. Unity запоминает: «Этот объект во всем слушается префаба, кроме цвета — цвет у него свой собственный».

У переопределений есть важное правило приоритета: локальное изменение всегда сильнее глобального. Если вы переопределили цвет одной монеты на золотой, а затем зашли в Prefab Mode и сделали весь шаблон серебряным, все монеты станут серебряными, кроме вашей золотой — она сохранит свою уникальность.

Если вы поняли, что локальное изменение получилось настолько удачным, что его нужно применить ко всем остальным объектам, в шапке Инспектора есть меню Overrides. Там можно нажать кнопку Apply All (Применить всё), и ваши локальные изменения запишутся в главный шаблон, обновив все остальные копии.

Разрыв связи: Unpack Prefab

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

Кликнув правой кнопкой мыши по синему объекту в Иерархии, вы можете выбрать Prefab -> Unpack (Распаковать). Текст объекта снова станет черным. Он превратится в обычный независимый GameObject. Изменения главного шаблона на него больше не повлияют.

Понимание связки «Ассет → Префаб → Экземпляр» — это фундамент архитектуры любой игры в Unity. Выстраивая уровни из префабов, а не из разрозненных объектов, вы закладываете возможность легко менять баланс и визуал игры на поздних этапах разработки.

Сборка первой композиции: От пустого проекта к игровой сцене

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

В этой главе мы пройдем путь от пустого серого экрана до готовой стартовой локации вашей первой 2D-игры.

Шаг 1: Камера — режиссерский пульт

Каждый новый проект в Unity встречает нас объектом Main Camera в окне Иерархии. Камера — это глаза игрока. То, что попадает в ее прямоугольный объектив на сцене, транслируется в окно Game.

Если вы выделите Main Camera и посмотрите в Инспектор, то найдете компонент Camera. Для 2D-игр нас интересует свойство Background (Фон). По умолчанию это унылый темно-синий цвет. Кликните на цветовое поле и выберите яркий небесно-голубой оттенок. Окно Game тут же преобразится — мы задали настроение нашей сцене.

Шаг 2: Закладка фундамента и сила дубликатов

Игроку нужно по чему-то ходить. Создадим первый элемент уровня:

1. Добавьте в сцену базовый 2D-примитив (Square).
2. В Инспекторе через компонент Sprite Renderer покрасьте его в зеленый цвет.
3. Используя инструмент Rect Tool, растяните его так, чтобы он напоминал блок земли.

Если мы захотим построить длинную платформу, создавать каждый блок с нуля — плохая идея. Перетащите наш зеленый блок из Иерархии в окно Project. Поздравляем, вы создали префаб GroundTile.

Теперь выделите GroundTile на сцене и нажмите Ctrl + D (или Cmd + D на Mac). Unity создаст точную копию объекта. Сдвиньте ее вбок. Повторите это действие десять раз, выстраивая блоки в ровную линию.

Шаг 3: Наведение порядка в Иерархии

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

Используем механику вложенности для организации пространства:

1. Создайте пустой GameObject (Create Empty).
2. Назовите его Environment (Окружение).
3. Убедитесь, что его координаты в компоненте Transform сброшены в нули ($X = 0$, $Y = 0$, $Z = 0$).
4. Выделите все блоки земли и перетащите их внутрь Environment.

Теперь блоки стали потомками (Child) пустого объекта. Вы можете свернуть список Environment, и Иерархия снова станет чистой. Если вы выделите родительский объект и подвинете его, вся платформа переместится целиком.

Шаг 4: Главный герой и сортировка слоев

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

Здесь в 2D-играх часто возникает проблема: красный квадрат может оказаться за зелеными блоками, спрятавшись в текстурах. В трехмерном пространстве мы бы просто придвинули героя ближе к камере по оси Z. В 2D-проектах Unity предлагает более элегантный инструмент прямо в компоненте Sprite Renderer — свойство Order in Layer (Порядок в слое).

Чем выше число в Order in Layer, тем ближе объект к экрану:

• У блоков земли Order in Layer равен $0$.
• Выделите Player и установите ему Order in Layer равным $1$.

Красный квадрат гарантированно отрисуется поверх земли, независимо от их физических координат по оси Z.

Шаг 5: Запуск симуляции

Сцена собрана. У нас есть фон, земля, сгруппированная в папку, и главный герой. Нажмите кнопку Play (▶) в самом верху по центру редактора Unity.

Интерфейс слегка потемнеет. Окно Game станет активным. Сейчас, если вы нажмете на клавиши клавиатуры, ничего не произойдет. Красный квадрат будет неподвижно висеть в воздухе.

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

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