Разработка игр в Unity 6 с нуля

Установка Unity 6 и обзор редактора

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

Что нужно установить и как это устроено

Unity для разработки игры обычно состоит из двух частей:

Unity Hub — отдельная программа-менеджер, через которую удобно ставить разные версии Unity, добавлять модули (например, Android) и управлять проектами.

Unity Editor — сам редактор (Unity 6), где ты создаёшь сцену, добавляешь объекты, настраиваешь графику, пишешь скрипты и запускаешь игру.

Также в процессе почти всегда нужна среда разработки для C# (язык скриптов в Unity).

Системные требования

Перед установкой проверь базовые требования на официальной странице Unity Manual:

Unity Manual: System requirements

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

8–16 ГБ оперативной памяти

современная видеокарта с актуальными драйверами

свободное место на диске под редактор и проекты

Установка Unity Hub

Открой страницу загрузки Unity.

Скачай и установи Unity Hub для своей операционной системы.

Официальная страница:

Unity Download

Документация по Hub (если что-то пойдёт не так):

Unity Manual: Unity Hub

Установка Unity 6 через Unity Hub

Запусти Unity Hub.

Открой вкладку Installs.

Нажми Install Editor.

Выбери Unity 6.

На шаге выбора модулей отметь нужное.

Что выбрать в модулях на старте (рекомендация для новичка):

Microsoft Visual Studio или настройка внешнего редактора (нужно для C#)

Windows Build Support или Mac Build Support (обычно ставится по умолчанию под твою ОС)

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

Android

iOS

WebGL

Важно понимать простое правило: без установленного модуля сборки Unity не сможет собрать игру под соответствующую платформу.

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

В Unity Hub открой вкладку Projects.

Нажми New project.

Выбери шаблон.

Укажи имя проекта и папку.

Нажми Create project.

Как выбрать шаблон:

2D — если делаешь 2D-игру (спрайты, тайлмапы).

3D (URP) — хороший старт для 3D: современный рендеринг и нормальная производительность.

3D (HDRP) — обычно не для старта, требует более мощного железа и сложнее в настройке.

Термины, которые важно не путать:

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

Сцена — один “уровень” или “экран” игры (например, меню или первый уровень).

Объект (GameObject) — сущность на сцене (например, игрок, камера, свет).

Компонент — “возможность” объекта (например, Transform, камера, коллайдер, скрипт).

Обзор интерфейса Unity Editor

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

!Схема показывает где находятся ключевые окна редактора и как они называются

Главное: окна и их назначение

| Окно | Что это | Зачем нужно | |---|---|---| | Scene | Редакторская “рабочая область” сцены | Расставлять объекты, двигать камеру, настраивать окружение | | Game | Вид “глазами игрока” из камеры | Проверять, как выглядит игра при запуске | | Hierarchy | Список объектов текущей сцены | Быстро находить и выбирать объекты | | Inspector | Свойства выбранного объекта | Настраивать компоненты, добавлять новые | | Project | Файлы проекта (Assets) | Импортировать и организовывать ресурсы | | Console | Логи, предупреждения и ошибки | Смотреть сообщения и ошибки скриптов |

Toolbar и режим Play

В верхней части редактора находится панель с главным управлением:

Play — запускает игру прямо в редакторе

Pause — ставит игру на паузу

Step — делает один “шаг” вперёд, когда игра на паузе

Критически важный момент для новичка:

Изменения, сделанные во время Play, часто не сохраняются после остановки Play.

Первые действия в редакторе

Как выбрать и перемещать объекты

Выбери объект в Hierarchy.

Посмотри его компоненты в Inspector.

Попробуй инструменты перемещения в верхней панели инструментов сцены:

Move — перемещение

Rotate — вращение

Scale — масштаб

Компонент Transform есть у любого объекта. Он хранит:

Position — позицию

Rotation — поворот

Scale — масштаб

Как добавить объект на сцену

Открой меню создания объектов в сцене.

Добавь, например, куб.

Обрати внимание: он появится в Hierarchy, а его настройки — в Inspector.

Где настраивается внешний редактор кода

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

Открой настройки редактора.

Найди параметр External Script Editor.

Выбери Visual Studio или другую IDE.

Если Visual Studio не установилась вместе с Unity, её можно поставить отдельно с официального сайта:

Visual Studio

Частые проблемы при установке и запуске

Unity Hub не видит установленный Editor

1. Проверь, что установка сделана через Hub. 2. Если Editor установлен вручную, добавь его через поиск установок в Hub.

Ошибки графики, артефакты, чёрный экран в Scene/Game

1. Обнови драйвер видеокарты. 2. Проверь системные требования.

Не открываются C#-скрипты по двойному клику

1. Проверь настройку External Script Editor. 2. Убедись, что установлены компоненты для разработки на C#.

Что дальше по курсу

Дальше мы начнём собирать первую мини-сцену: научимся создавать объекты, настраивать компоненты, работать с камерой и светом, а затем перейдём к скриптам на C# и управлению поведением объектов.

Основы C# и скрипты в Unity

В прошлой статье ты установил Unity 6, создал проект и освоился с окнами редактора. Дальше логичный шаг — оживить объекты: заставить игрока двигаться, счёт — расти, а врагов — реагировать на столкновения. В Unity это делается через скрипты на C#.

Что такое скрипт в Unity

Скрипт — это C#-файл, который обычно содержит класс (тип данных), описывающий поведение. Когда ты добавляешь скрипт как компонент на объект (GameObject), Unity начинает вызывать определённые методы этого класса во время работы игры.

Ключевая идея Unity:

GameObject — “контейнер” на сцене.

Component — “способность” объекта.

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

Официально про устройство скриптинга:

Раздел про скриптинг в Unity Manual

Как создать и подключить скрипт

В окне Project открой папку Assets.

Нажми правой кнопкой мыши и выбери Create → C# Script.

Назови скрипт (важно): имя файла должно совпадать с именем класса внутри.

Дважды кликни по скрипту — он откроется в IDE.

Перетащи скрипт на объект в Hierarchy или нажми Add Component в Inspector.

Важно:

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

Ошибки и предупреждения смотри в окне Console.

Минимальная структура C#-скрипта для Unity

Типичный стартовый шаблон (упрощённо выглядит так):

Разберём термины:

using UnityEngine; — подключение пространства имён Unity (чтобы были доступны Transform, Time, Debug и т.д.).

public class PlayerMover — объявление класса.

: MonoBehaviour — наследование от MonoBehaviour, чтобы Unity могла вызывать “магические” методы (Start, Update и другие).

Справка:

MonoBehaviour (Unity Scripting API)

Жизненный цикл: когда Unity вызывает методы

Unity вызывает методы твоего компонента в определённые моменты. Самые важные для старта:

Awake() — когда объект загружен (часто используется для первичной инициализации).

Start() — перед первым кадром, если компонент включён.

Update() — каждый кадр (подходит для ввода и простой логики).

FixedUpdate() — фиксированное количество раз в секунду (часто используется для физики).

!Схема, показывающая когда Unity вызывает основные методы скрипта

Подробнее (официально):

Порядок выполнения событий (Execution Order)

Переменные и типы: что тебе нужно в первую очередь

C# — статически типизированный язык: у каждой переменной есть тип.

Частые типы в Unity

| Тип | Пример | Для чего обычно | |---|---|---| | int | int hp = 100; | целые числа: здоровье, счёт | | float | float speed = 5f; | скорость, таймеры | | bool | bool isDead = false; | состояния: жив/мертв | | string | string playerName = "Alex"; | текст | | Vector3 | Vector3 dir = Vector3.forward; | позиции и направления в 3D | | Transform | Transform target; | доступ к позиции/повороту/масштабу объекта |

Примечания:

Для float в C# принято писать суффикс f, например 5f, чтобы число точно было типа float.

Vector3 — структура Unity для 3D-векторов (x, y, z). В 2D часто используют Vector2.

Если хочется укрепить базу C# отдельно от Unity:

Документация по C# (Microsoft Learn)

Поля компонента и Inspector: как настраивать скрипт без правки кода

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

Самый простой вариант: public

speed будет виден и редактируем в Inspector.

Более безопасный вариант: private + [SerializeField]

Это позволяет:

оставить поле приватным (к нему нельзя обратиться снаружи напрямую);

при этом сохранить редактирование в Inspector.

Справка:

SerializeField (Unity Scripting API)

Логи в Console: быстрый способ понять, что происходит

Для отладки на старте чаще всего хватает логов:

Справка:

Debug.Log (Unity Scripting API)

Практическое правило:

если “ничего не происходит”, сначала проверь: скрипт добавлен на объект, объект активен, нет ошибок в Console, и выводится ли Debug.Log.

Доступ к объекту и компонентам

Когда скрипт висит на объекте, у него есть быстрый доступ к:

transform — Transform того объекта, на котором находится скрипт.

gameObject — сам объект.

Пример: каждый кадр чуть двигаем объект вперёд.

Что здесь важно:

Vector3.forward — единичный вектор (0, 0, 1).

Time.deltaTime — время между кадрами: делает движение одинаковым при разном FPS.

Справка:

Time.deltaTime (Unity Scripting API)

Как получить другой компонент

Например, если нужно обратиться к Rigidbody или Renderer, используют GetComponent.

Справка:

Component.GetComponent (Unity Scripting API)

Практическое правило:

GetComponent лучше не вызывать “без нужды” каждый кадр в Update(); чаще компонент кэшируют в поле в Awake() или Start().

Простой ввод с клавиатуры: движение по осям

Для старта удобно использовать старую систему ввода через Input.GetAxis.

Что нужно знать:

Horizontal и Vertical — стандартные оси, заданные в настройках проекта.

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

Частые ошибки новичка и как их быстро чинить

Имя класса не совпадает с именем файла

Скрипт не висит на объекте

Объект выключен (галочка активности) или компонент отключён

Ошибки компиляции в Console блокируют выполнение

Изменения сделаны в Play Mode и пропали после остановки

Что дальше по курсу

Теперь у тебя есть базовый “язык управления” Unity: ты умеешь создавать скрипты, подключать их к объектам, работать с переменными, понимать Start/Update, читать Console и двигать объекты.

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

Сцены, объекты, компоненты и префабы

После установки Unity 6 и первых шагов со скриптами на C# пора разобраться, из чего в Unity собирается игра. Почти любой проект строится вокруг четырёх базовых понятий:

Сцена хранит “картину мира” (уровень, меню, тестовая площадка).

GameObject — объект на сцене (игрок, камера, кнопка, препятствие).

Компоненты добавляют объекту свойства и поведение (Transform, Renderer, Collider, твой скрипт).

Префабы позволяют превращать настроенные объекты в переиспользуемые “шаблоны”.

Понимание этой связки — фундамент для любой механики: движения, столкновений, UI, спавна врагов и сборки уровней.

!Схема связи сцены, объектов, компонентов и префабов

Сцена

Сцена — это файл, который описывает:

какие GameObject существуют в этом “уровне”

где они находятся (позиции/повороты/масштабы)

какие компоненты и настройки у них заданы

Типичные примеры сцен:

MainMenu

Level01

GameOver

Официальная документация:

Unity Manual: Scenes

Как создать и сохранить сцену

Создай новую сцену через меню File → New Scene.

Сразу сохрани её: File → Save или Save As.

Храни сцены в отдельной папке, например Assets/Scenes.

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

Что такое активная сцена

В редакторе обычно есть активная сцена — та, в которую будут добавляться новые объекты по умолчанию. При работе с несколькими сценами (например, отдельная сцена UI + сцена уровня) важно следить, куда именно ты создаёшь объекты.

GameObject

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

Ключевые особенности GameObject:

может иметь дочерние объекты (иерархия)

может быть включён или выключен

всегда имеет компонент Transform

Официальная документация:

Unity Manual: GameObjects

Hierarchy и родительство

Окно Hierarchy показывает список объектов сцены и их вложенность.

Зачем нужна вложенность:

можно “прикрепить” оружие к руке персонажа

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

трансформации наследуются: если родитель сдвинулся, дети тоже сдвинутся

Важный момент про Transform:

позиция/поворот/масштаб в Inspector показываются в локальных координатах относительно родителя

мировые значения можно смотреть через переключатель в Unity (зависит от режима отображения) и через код

Компоненты

Компонент — это модуль, который добавляет GameObject свойства или поведение. В Unity ты “собираешь” объект из компонентов, как из конструктора.

Официальная документация:

Unity Manual: Components

Transform — главный компонент

Transform есть у любого GameObject и отвечает за:

Position — позиция

Rotation — поворот

Scale — масштаб

Это та часть, с которой ты уже работал в скриптах через transform.position.

Типичные компоненты, которые встретятся почти сразу

| Компонент | Где используется | Что даёт | |---|---|---| | Camera | камера | картинка в окне Game | | Light | свет | освещение в 3D | | Mesh Renderer | 3D-объекты | отображение меша | | Sprite Renderer | 2D-объекты | отображение спрайта | | Collider/Collider2D | 3D/2D физика | столкновения и триггеры | | Rigidbody/Rigidbody2D | 3D/2D физика | физическое движение | | Audio Source | звук | проигрывание аудио | | Твой скрипт (MonoBehaviour) | логика | управление поведением |

Добавление и удаление компонентов

Выбери объект в Hierarchy.

В Inspector нажми Add Component.

Найди компонент по имени и добавь.

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

Практическое правило: если объект “не работает”, сначала проверь, есть ли у него нужные компоненты и включены ли они.

Включение/выключение объекта и компонента

Есть два разных уровня отключения:

выключить GameObject (галочка активности вверху Inspector) — выключится всё на объекте и его детях

выключить компонент (галочка в заголовке компонента) — объект остаётся активным, но конкретная “способность” отключается

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

Префабы

Префаб — это ассет-шаблон GameObject в окне Project, который можно много раз размещать на сцене как экземпляр.

Зачем нужны префабы:

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

единые правки: меняешь шаблон — обновляются экземпляры

удобный спавн из кода (позже ты будешь создавать врагов через Instantiate)

Официальная документация:

Unity Manual: Prefabs

Как создать префаб

Создай и настрой GameObject на сцене (меш/спрайт, коллайдер, нужные параметры, твой скрипт).

Перетащи этот объект из Hierarchy в папку в Project, например Assets/Prefabs.

Unity создаст prefab asset.

Теперь можно удалять объект со сцены и добавлять экземпляры префаба перетаскиванием из Project в Scene.

Экземпляр префаба и изменения

Когда префаб размещён на сцене, это Prefab Instance.

С ним есть два важных режима изменений:

изменения в экземпляре только для этого экземпляра (это называется override)

изменения в самом prefab asset применяются ко всем экземплярам

Практическое правило: если тебе нужен “такой же, но чуть другой” объект много раз, чаще всего лучше сделать новый префаб или вариант префаба, а не раздавать overrides по сцене.

Prefab Variant

Если нужен базовый враг и несколько его разновидностей (быстрый, бронированный, с другим цветом), используют Prefab Variant — префаб, который наследуется от другого префаба.

Официальная документация:

Unity Manual: Prefab Variants

Рекомендуемая структура папок в Project

Строгих правил нет, но новичку полезно начать с понятной структуры:

Assets/Scenes

Assets/Scripts

Assets/Prefabs

Assets/Materials или Assets/Art

Assets/Audio

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

Как это связано со скриптами из прошлой статьи

Скрипт на C# в Unity почти всегда:

является компонентом (наследуется от MonoBehaviour)

добавляется на GameObject

живёт в сцене как часть объекта

может быть частью префаба

Самый типичный рабочий цикл выглядит так:

Создал сцену.

Добавил GameObject (игрок/враг/предмет).

Добавил компоненты (Renderer, Collider, Rigidbody).

Добавил скрипт, настроил поля через Inspector.

Превратил объект в префаб, чтобы переиспользовать и спавнить.

Что дальше по курсу

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

Управление игроком, камера и физика

После прошлых статей ты уже понимаешь, как устроены сцены, GameObject, компоненты и как подключать скрипты на C#. Теперь соберём базовую “игровую петлю”: игрок управляется с клавиатуры, камера следует за ним, а движение и прыжки работают через физику Unity.

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

Два подхода к движению игрока

В Unity есть два популярных способа двигать персонажа.

| Подход | Как двигаем | Плюсы | Минусы | Когда использовать | |---|---|---|---|---| | “Без физики” | меняем transform.position | просто и быстро | легко “проталкивать” сквозь стены, сложнее с столкновениями | прототип, простые 2D/аркады без сложной физики | | Физический | Rigidbody + перемещение в FixedUpdate | корректные столкновения и взаимодействия | нужно понимать физические компоненты и настройки | почти любые игры, где важны коллизии |

Дальше мы делаем физический вариант: Rigidbody + коллайдер.

Подготовка сцены для теста управления

Создай простую тестовую сцену

Создай сцену PlayerTest и сохрани в Assets/Scenes.

Добавь пол:

- GameObject → 3D Object → Plane - убедись, что у него есть Mesh Collider (обычно он добавляется автоматически)

Добавь игрока:

- GameObject → 3D Object → Capsule - переименуй в Player - поставь чуть выше пола по Y (например, Y = 1)

Добавь физику игроку

На объект Player добавь компоненты:

Rigidbody

Capsule Collider (обычно уже есть)

В Rigidbody включи:

Use Gravity: включено

Is Kinematic: выключено

Проверь в Play Mode: капсула должна падать на плоскость и останавливаться.

Ввод: откуда брать нажатия клавиш

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

Horizontal обычно привязан к A/D и стрелкам влево/вправо

Vertical обычно привязан к W/S и стрелкам вверх/вниз

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

Полезные официальные ссылки:

Unity Manual: Input

Unity Manual: Input System package

Скрипт движения через Rigidbody

Почему движение через Rigidbody делается в FixedUpdate

Физика Unity работает в фиксированных шагах. Поэтому:

ввод удобно читать в Update (он вызывается каждый кадр)

двигать Rigidbody лучше в FixedUpdate (он вызывается синхронно с физикой)

!Схема различия Update, FixedUpdate и LateUpdate

PlayerRigidbodyMover.cs

Создай скрипт PlayerRigidbodyMover в Assets/Scripts.

Добавь его на объект Player.

Что здесь важно:

Rigidbody.MovePosition двигает тело “физически корректнее”, чем прямое изменение transform.position

Time.fixedDeltaTime это длительность шага физики

[RequireComponent(typeof(Rigidbody))] помогает не забыть Rigidbody: Unity покажет предупреждение и добавит компонент при необходимости

Справка по компонентам:

Unity Scripting API: Rigidbody

Unity Scripting API: Rigidbody.MovePosition

Поворот игрока по направлению движения

Чтобы капсула “смотрела” в сторону движения, можно поворачивать её в FixedUpdate, когда есть ввод.

Добавь в конец FixedUpdate:

Справка:

Unity Scripting API: Rigidbody.MoveRotation

Unity Scripting API: Quaternion.LookRotation

Прыжок и проверка “на земле”

Прыжок почти всегда требует проверки: стоит ли игрок на поверхности.

Один из простых способов для старта: Physics.Raycast вниз.

PlayerJump.cs

Создай скрипт PlayerJump и добавь на Player.

Что здесь важно:

нажатие пробела читаем в Update, а силу применяем в FixedUpdate

ForceMode.Impulse добавляет “мгновенный толчок”

LayerMask позволяет ограничить, какие поверхности считаются землёй

Справка:

Unity Scripting API: Rigidbody.AddForce

Unity Scripting API: Physics.Raycast

Unity Scripting API: LayerMask

Камера: простой follow за игроком

Самый простой стартовый вариант: камера хранит смещение (offset) и каждый кадр ставит себя относительно игрока.

Почему часто используют LateUpdate:

LateUpdate вызывается после Update

это помогает камере “догнать” игрока в том же кадре и уменьшить дрожание

!Схема смещения камеры относительно игрока

SimpleFollowCamera.cs

Повесь этот скрипт на объект Main Camera.

Как настроить:

перетащи Player в поле Target в Inspector

подбери Offset под удобный вид

если камера “плывёт” слишком медленно или быстро, меняй Follow Speed

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

Unity Manual: Cinemachine

База физики Unity, которая нужна прямо сейчас

Collider и Rigidbody: кто за что отвечает

Collider определяет форму для столкновений

Rigidbody делает объект участником физической симуляции (масса, гравитация, силы)

Обычно, чтобы игрок сталкивался со стенами:

у игрока: Rigidbody + Collider

у стены/пола: достаточно Collider

Trigger и обычная коллизия

У коллайдера есть режим Is Trigger:

если выключено: физика “толкается” и не даёт проходить сквозь объект

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

Справка:

Unity Manual: Colliders

Unity Manual: Rigidbody

Настройки Rigidbody, которые часто влияют на управление

| Настройка | Что меняет | Типичный совет для новичка | |---|---|---| | Mass | “тяжесть” тела | оставь по умолчанию, меняй позже осознанно | | Drag / Angular Drag | затухание скорости/вращения | если игрок “скользит”, немного увеличь Drag | | Constraints | запрет осей | для капсулы часто фиксируют вращение по X и Z, чтобы не заваливалась | | Interpolate | сглаживание визуального движения | включи, если заметны рывки при движении | | Collision Detection | режим детекта столкновений | для быстрых объектов может помочь Continuous |

Частые проблемы и быстрые проверки

Игрок проходит сквозь пол: проверь, что у пола есть Collider и он не Trigger.

Игрок не двигается: проверь, что скрипт висит на Player, нет ошибок в Console, Rigidbody не кинематический.

Камера не следует: проверь ссылку Target в SimpleFollowCamera.

Прыжок не работает: проверь groundCheckDistance и что groundMask включает слой пола.

Что дальше по курсу

Теперь у тебя есть базовая связка управление + камера + физическая сцена. Следующий логичный шаг: научиться делать взаимодействия через коллизии и триггеры (подбор предметов, урон, победа/поражение) и собирать мини-игру из префабов.

Игровая логика: взаимодействия, враги и события

В прошлой статье ты сделал базовое управление игроком через Rigidbody, добавил прыжок и простую камеру. Теперь пора превратить “сцену с капсулой” в игровую ситуацию: игрок подбирает предметы, получает урон от врагов, а игра реагирует на победу и поражение.

Эта статья про три главных строительных блока геймплея:

Взаимодействия через коллизии и триггеры

Враги как набор компонентов: движение + нанесение урона

События как способ “сообщать” другим системам о том, что произошло (смерть, победа, сбор предмета)

!Схема связи объектов и событий в мини-игре

Взаимодействия в Unity: коллизии и триггеры

Что нужно для столкновений

Чтобы Unity могла “замечать” контакт объектов, почти всегда нужны:

Collider у объектов (форма столкновения)

Rigidbody хотя бы у одного из двух объектов (участник физики)

Официально:

Colliders (Unity Manual)

Rigidbody (Unity Manual)

Коллизия и триггер: в чём разница

Коллизия (у коллайдера Is Trigger выключен): объекты физически “упираются” и не проходят друг сквозь друга.

Триггер (у коллайдера Is Trigger включен): физически не мешает, но позволяет ловить событие входа/выхода из зоны.

Типичные сценарии:

Коллизия: стены, пол, “тело” врага

Триггер: монетки, зона победы, ловушки-зоны

Методы, которые вызываются при контакте

В 3D чаще всего используются:

OnCollisionEnter(Collision collision) для коллизий

OnTriggerEnter(Collider other) для триггеров

Справка:

MonoBehaviour.OnCollisionEnter (Unity Scripting API)

MonoBehaviour.OnTriggerEnter (Unity Scripting API)

Мини-игра для практики: цель, объекты, правила

Соберём маленький прототип, который удобно расширять:

Игрок бегает и прыгает (у тебя уже есть)

На уровне есть монетки (подбор через триггер) и счёт

Есть враг-патруль, который наносит урон при контакте

Есть зона победы, которая завершает игру

Рекомендуемая структура сцены:

Player

Enemy

Coins (несколько экземпляров префаба)

WinZone

GameManager

События: как сообщать “что-то случилось” без жёстких связей

Когда появляется логика, возникает типичная проблема: кто должен знать о чём?

Примеры:

Монетка подобрана: нужно увеличить счёт, проиграть звук, возможно обновить UI

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

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

Прямой вызов: компонент находит GameManager и вызывает метод

Событие: компонент сообщает “произошло X”, а подписчики решают, что делать

В Unity есть удобный инструмент событий, который видно в Inspector: UnityEvent.

Справка:

UnityEvent (Unity Scripting API)

Компонент здоровья: основа урона и смерти

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

Health.cs

Создай Assets/Scripts/Health.cs и добавь на Player.

Что важно:

maxHp редактируется в Inspector

CurrentHp меняется только изнутри компонента (это уменьшает случайные ошибки)

OnDied можно настроить в Inspector без кода: например, вызвать GameManager.GameOver()

Урон при контакте: один компонент для врагов и ловушек

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

Есть два варианта:

через коллизию (OnCollisionEnter) если враг физически “толкается”

через триггер (OnTriggerEnter) если ты хочешь зону урона

Для старта сделаем вариант через коллизию.

DamageOnContact.cs

Создай Assets/Scripts/DamageOnContact.cs и добавь на Enemy.

Практические замечания:

Это намеренно простой вариант: урон наносится при каждом новом столкновении

Позже ты можешь добавить “кулдаун урона” (чтобы не снимать здоровье слишком быстро)

Враг-патруль: движение между точками

Сделаем врага, который ходит между точками A и B.

Подготовка

Создай объект Enemy (например, Cube).

Добавь компоненты:

- Rigidbody - Box Collider

В Rigidbody обычно удобно включить ограничения, чтобы куб не заваливался:

- Constraints: Freeze Rotation X, Freeze Rotation Z

Создай два пустых объекта PointA и PointB и расставь их на сцене.

EnemyPatrol.cs

Создай Assets/Scripts/EnemyPatrol.cs и добавь на Enemy.

Как настроить:

Перетащи PointA и PointB в поля скрипта у врага

Подбери speed

Почему здесь FixedUpdate:

это движение через Rigidbody, как и у игрока из прошлой статьи

Подбор предметов: монетка через триггер

Префаб монетки

Создай объект Coin (например, Sphere).

Добавь Sphere Collider.

Включи Is Trigger.

Преврати объект в префаб (как в статье про префабы): перетащи в Assets/Prefabs.

Логика счёта

Сделаем простой GameManager, который хранит счёт и знает, когда игра закончена.

#### GameManager.cs

Создай Assets/Scripts/GameManager.cs и добавь на отдельный объект GameManager.

Это простой вариант, который:

даёт быстрый результат

помогает не “провалиться” в UI и архитектуру слишком рано

CoinPickup.cs

Создай Assets/Scripts/CoinPickup.cs и добавь на префаб Coin.

Важно:

У игрока должен быть тег Player. Настрой его в Inspector у объекта Player.

У игрока должен быть Collider и Rigidbody (у тебя уже есть).

Справка про теги:

Tags (Unity Manual)

Зона победы

Сделаем WinZone, который завершает игру при входе игрока.

WinZone.cs

Создай объект WinZone (например, Cube).

Добавь Box Collider.

Включи Is Trigger.

Создай скрипт и добавь на WinZone.

Соединяем смерть игрока с окончанием игры

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

Сделай так:

Выбери Player.

В компоненте Health найди событие On Died.

Нажми +.

Перетащи объект GameManager в появившееся поле.

В выпадающем списке выбери GameManager → GameOver().

Так ты связал событие смерти с действием менеджера, не прописывая жёсткую ссылку из Health на GameManager.

Частые проблемы и быстрые проверки

Триггер не срабатывает: проверь, что у одного из объектов есть Rigidbody, и что Is Trigger включён именно там, где ты ожидаешь.

Монетка не подбирается: проверь тег Player у игрока и наличие коллайдера.

Урон не наносится: проверь, что у игрока есть Health, а у врага DamageOnContact.

Враг падает и крутится: зафиксируй вращение в Rigidbody Constraints.

Игра продолжает начислять счёт после победы: проверь, что используется IsGameFinished и что GameManager на сцене в единственном экземпляре.

Что дальше по курсу

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

Следующий логичный шаг: улучшать ощущение игры и удобство разработки: UI для счёта и состояния, спавн из префабов, более аккуратная архитектура (чтобы расширять проект без переписывания половины кода).

UI, аудио, сохранения и базовая оптимизация

В предыдущих статьях ты сделал управление игроком, врага, монетки, зону победы и базовый GameManager, который хранит счёт и фиксирует состояние игры. Сейчас прототип уже “работает”, но ощущается как набор кубов с логами в Console.

Эта статья закрывает четыре практических слоя, без которых игра обычно не воспринимается как игра:

UI: показываем счёт, здоровье и состояние победы/поражения

Аудио: добавляем звуки действий и музыку

Сохранения: сохраняем, например, лучший счёт и настройки громкости

Базовая оптимизация: делаем так, чтобы проект не тормозил и не “подлагивал” из-за типичных ошибок новичка

!Диаграмма показывает, как логика, UI и аудио связываются через менеджеры и события

UI: как показать игроку, что происходит

UI в Unity чаще всего строят на системе uGUI:

Canvas — “холст”, на котором рисуются UI-элементы

RectTransform — Transform для UI (позиция и размер в рамках Canvas)

EventSystem — система событий (клики, наведение, выбор)

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

UI system (Unity Manual)

Canvas (Unity Manual)

Что мы сделаем в прототипе

Текст счёта

Текст здоровья

Панель победы

Панель поражения

Кнопка перезапуска сцены

Чтобы текст выглядел нормально, удобно использовать TextMesh Pro.

TextMesh Pro package documentation

Создаём HUD на сцене

Создай Canvas: GameObject → UI → Canvas.

Unity обычно автоматически создаст EventSystem.

Внутри Canvas создай:

- ScoreText (UI Text - TextMeshPro) - HpText (UI Text - TextMeshPro) - WinPanel (UI Panel) - LosePanel (UI Panel)

Внутри WinPanel и LosePanel добавь тексты и кнопку Restart.

Сделай WinPanel и LosePanel выключенными (неактивными) по умолчанию.

Обновляем UI не через “поиск каждый кадр”, а через события

Сейчас GameManager увеличивает счёт и пишет в Debug.Log. Для UI лучше, чтобы менеджер сообщал, что значение изменилось.

Ниже простой вариант на C#-событиях.

#### GameManager.cs (обновлённый)

Заменяй свой GameManager на версию ниже или аккуратно добавь части.

Что это даёт:

UI не обязан “ходить” в GameManager каждый кадр

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

UI-скрипт: показываем счёт, здоровье, победу/поражение

Создай Assets/Scripts/HUDController.cs, повесь на объект внутри Canvas (например, HUD).

Важно:

Поля scoreText, hpText, winPanel, losePanel, playerHealth заполни через Inspector

Метод RestartLevel() подключи в Button.onClick

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

SceneManager (Unity Scripting API)

Делаем Health “дружелюбным” к UI

В прошлой статье Health сообщал только о смерти через UnityEvent. Добавим событие изменения здоровья.

#### Health.cs (обновление)

Аудио: SFX и музыка

Минимальный набор аудио в прототипе:

звук подбора монетки

звук получения урона или смерти

звук победы

фоновая музыка

Основные компоненты:

AudioSource — “проигрыватель” звука на объекте

AudioClip — сам звуковой файл

AudioMixer — микшер, чтобы управлять громкостью групп (музыка отдельно от SFX)

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

Audio (Unity Manual)

Audio Source (Unity Manual)

Audio Mixer (Unity Manual)

Простой AudioManager

Создай пустой объект AudioManager и добавь на него AudioSource.

Рекомендация:

один AudioSource для музыки (Loop включён)

один AudioSource для SFX (Loop выключён)

#### AudioManager.cs

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

AudioSource.PlayOneShot (Unity Scripting API)

Подключаем звуки к событиям игры

В CoinPickup.cs после AddScore добавь вызов:

В GameManager.Win() и GameManager.GameOver() добавь:

и

Так у тебя появится обратная связь от действий.

Сохранения: лучший счёт и настройки через PlayerPrefs

Для простых данных (числа, строки, флаги) удобно использовать PlayerPrefs.

Это подходит для:

лучший счёт

громкость музыки и SFX

выбранный уровень сложности

Это плохо подходит для:

сложные структуры данных (инвентарь, мир, квесты)

защищённые данные (их легко подделать)

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

PlayerPrefs (Unity Scripting API)

Сохраняем лучший счёт

Добавь в GameManager сохранение рекорда при победе или при окончании игры.

И вызови SaveBestScoreIfNeeded() в Win() и GameOver() перед выставлением панелей UI.

Показываем лучший счёт в UI

Добавь в HUD ещё один TMP_Text (например, bestScoreText) и обновляй его в Start():

Базовая оптимизация: что важно новичку

Оптимизация в Unity почти всегда начинается не с “магических настроек”, а с дисциплины:

не делать тяжёлые операции каждый кадр

не создавать мусор для сборщика памяти без необходимости

проверять себя в Profiler

Unity Profiler: где смотреть проблемы

Открой окно:

Window → Analysis → Profiler

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

Profiler (Unity Manual)

На старте тебе важнее всего два модуля:

CPU Usage: что грузит процессор

GC Alloc: выделения памяти, которые могут вызывать микрофризы

Типичные “дорогие” ошибки и как их убрать

| Ошибка | Почему плохо | Что делать вместо этого | |---|---|---| | FindObjectOfType, GameObject.Find в Update | поиск по сцене дорогой | находить один раз в Awake/Start или прокидывать ссылки через Inspector | | GetComponent в Update | лишняя работа каждый кадр | кэшировать компонент в поле в Awake/Start | | частое Instantiate/Destroy (например, пули) | создаёт нагрузку и мусор | использовать простейший пул объектов (object pooling) | | Debug.Log спамится каждый кадр | тормозит редактор и сборку | логировать только события, либо выключать в релизе | | скрипт “опрашивает” состояние, вместо событий | лишние проверки | подписки на события (ScoreChanged, HpChanged) |

Минимальный object pooling в двух словах

Если у тебя часто появляются и исчезают одинаковые объекты (пули, враги, эффекты), подход такой:

заранее создать несколько объектов

выключать и включать их вместо Instantiate/Destroy

Даже простейший пул часто убирает микрофризы.

Физика и кадры: не смешивай Update и FixedUpdate

Ты уже использовал это в управлении:

ввод читаем в Update

физическое движение делаем в FixedUpdate

Это помогает сделать поведение стабильным.

Итог

Теперь твой прототип стал похож на настоящую игру:

UI показывает счёт, здоровье и завершение игры

аудио даёт обратную связь (монетки, победа, поражение)

рекорд сохраняется между запусками

ты понимаешь базовые принципы оптимизации и умеешь проверять себя через Profiler

Дальше обычно развивают проект в двух направлениях:

удобство разработки и масштабирование (спавн, уровни, более аккуратная архитектура)

улучшение “ощущения игры” (анимации, эффекты, более продвинутая камера)

Сборка, тестирование и публикация проекта

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

В Unity это обычно выглядит как цепочка:

подготовить проект к сборке

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

собрать билд

протестировать билд (не в редакторе)

упаковать и опубликовать

!Общая схема: от проекта в Unity до публикации

Подготовка проекта к сборке

Проверь сцены и порядок загрузки

Unity собирает только те сцены, которые добавлены в список сборки.

Открой окно: File → Build Profiles или File → Build Settings (название может отличаться по версии редактора).

Найди список сцен для сборки.

Добавь нужные сцены и выставь порядок.

Практическое правило:

сцена с меню или стартом игры обычно идёт первой

тестовые сцены лучше не добавлять в сборку

Официальная документация:

Build Settings (Unity Manual)

Проверь ссылки на сцены в коде

Если ты перезагружаешь сцену через SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);, то важно, чтобы сцена была добавлена в список сборки.

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

SceneManager (Unity Scripting API)

Проверь, что в проекте нет ошибок компиляции

Если в Console есть красные ошибки, сборка либо не начнётся, либо получится сломанной.

Минимальный чек-лист перед билдом:

нет красных ошибок в Console

игра запускается в Play Mode

победа/поражение работают

UI и звук работают

сохранение рекорда работает

Подготовь папки и порядок в проекте

Чтобы не захламлять репозиторий и проект:

держи сборки отдельно от Assets, например в папке Builds рядом с проектом

не складывай готовые билды внутрь Assets (они не должны импортироваться как ассеты)

Настройка платформы и сборка

Build Settings: платформа и запуск сборки

В окне сборки выбирается:

платформа (Windows, macOS, WebGL, Android, iOS)

список сцен в билде

кнопки Build и Build And Run

Термины:

Build — Unity создаёт папку с готовыми файлами игры

Build And Run — Unity собирает и сразу запускает билд

Официально:

Build Settings (Unity Manual)

Development Build: билд для тестирования

Для тестов почти всегда полезно включать Development Build.

Что это даёт:

больше диагностической информации

проще ловить проблемы, которые не видны в редакторе

Важное правило:

Development Build не предназначен для публикации, это формат для проверки

Player Settings: имя, версия, иконка, параметры приложения

Настройки игрока влияют на то, как игра выглядит и ведёт себя как приложение.

Что стоит настроить даже в прототипе:

Product Name — имя игры

Company Name — автор или студия

Version — версия билда (например, 0.1.0)

иконки и курсор (если нужно)

параметры окна и разрешения

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

Player Settings (Unity Manual)

!Ключевые параметры Player Settings перед публикацией

Версионирование: как не запутаться в билдах

Простая схема для новичка:

0.1.0 — первая играбельная версия

0.1.1 — мелкие исправления без новых механик

0.2.0 — добавили заметную механику или контент

Главная цель версий:

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

проще собирать отзывы и чинить баги

Тестирование билда: что проверять вне редактора

Тестирование в редакторе и тестирование готового билда — это разные вещи.

Почему билды ломаются чаще, чем ожидают:

в редакторе некоторые ресурсы подхватываются иначе

путь к файлам и разрешения в системе отличаются

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

в WebGL и на мобильных ограничения сильнее

Мини-чек-лист функционального теста

Проверь в собранном билде:

игра запускается без ошибок

управление работает (клавиатура, мышь)

камера ведёт себя корректно

монетки подбираются, счёт обновляется

враг наносит урон, здоровье уменьшается

победа/поражение показывают нужные панели

кнопка Restart перезапускает уровень

лучший счёт сохраняется и отображается после перезапуска игры

Где смотреть логи и как ловить ошибки

Для диагностики полезны:

Debug.Log (но не спамить каждый кадр)

Development Build

профилирование

Профилирование:

Window → Analysis → Profiler

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

Profiler (Unity Manual)

Практическое правило:

если у игрока жалоба на фризы, смотри на CPU Usage и GC Alloc в Profiler

Тестирование на разных компьютерах

Если ты собираешь под Windows или macOS, попробуй:

запустить билд на другом ПК

проверить, что игра не требует Unity или Visual Studio

проверить, что настройки управления и разрешение окна адекватны

Это часто выявляет проблемы, которые ты не видишь на своей машине.

Особенности платформ: что важно знать новичку

Ниже кратко и по делу, чтобы ты не утонул в деталях.

Windows

Обычно собирается в папку, где лежат:

.exe

папка _Data

дополнительные файлы (зависит от настроек)

Правило публикации:

пользователю нужно отдать всю папку билда, а не только .exe

macOS

Чаще всего получается .app.

Совет:

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

WebGL

WebGL удобен для демо: игра запускается в браузере.

Важные ограничения WebGL:

производительность ниже, чем у нативных билдов

загрузка может быть долгой (особенно с большими ассетами)

работа с файлами и сохранениями ограничена средой браузера

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

WebGL (Unity Manual)

Android и iOS

На мобильных появляется больше обязательных нюансов:

ориентация экрана

разрешения

управление (тач)

производительность и размер приложения

Для новичка базовая цель простая:

сначала доведи прототип до стабильного билда на ПК

потом переноси на мобильные платформы

Подготовка к публикации: упаковка и материалы

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

Что подготовить перед загрузкой

папка с билдом

README.txt с короткой инструкцией

список управления (например, WASD, Space)

известные проблемы (если есть)

версия билда (та же, что в Player Settings)

Публикация на itch.io как простой старт

Itch.io часто используют как первую площадку, потому что там легко выкладывать прототипы.

Общий процесс:

Создай страницу проекта.

Загрузи билд (обычно архивом).

Заполни описание, управление, скриншоты.

Протестируй скачивание и запуск как “обычный пользователь”.

Справка:

Uploading your game (itch.io documentation)

Частые проблемы при сборке и как быстро проверить

Чёрный экран после запуска: проверь, что нужная сцена стоит первой в списке сцен для сборки.

Не работает переход/перезапуск сцен: проверь, что сцена добавлена в билд.

Нет звука: проверь, что AudioListener есть на камере и что громкость источников не равна нулю.

Сохранения не работают: проверь, что используешь PlayerPrefs и вызываешь PlayerPrefs.Save() после записи.

В билде сильно медленнее: сравни Profiler, выключи спам Debug.Log, уменьши количество Instantiate/Destroy.

Итог

Теперь ты умеешь доводить прототип до полноценного билда:

правильно добавлять сцены в сборку

понимать разницу между тестовым Development Build и релизной сборкой

настраивать базовые Player Settings

тестировать игру вне редактора по чек-листу

готовить билд и материалы к публикации

На практике именно этот шаг отделяет “я сделал в Unity” от “в это могут поиграть другие”.