Unity 2D игра с нуля: инструкция по созданию для начинающих

Главная
Блог
Unity 2D игра с нуля: инструкция по созданию для начинающих

1. О чём это пошаговое руководство и какой результат вы получите

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

Как создать Unity 2D игру с нуля: пошаговое руководство для начинающих

Руководство ориентировано на два типа читателей:

новички в Unity, которые уже видели C# (понимают, что такое переменная, условие, метод) и хотят связать теорию с живым проектом;
дизайнеры, маркетологи, фаундеры, которые хотят понять реальный процесс разработки unity 2d игры с нуля, чтобы адекватно ставить задачи программистам и обсуждать бюджет.

Вы разберётесь, как:

создать new 2D-проект в Unity и организовать папки Assets;
собрать сцену: фон, препятствия, спрайты персонажа и бонусов, настроить камеру (Camera.main), добавить коллайдеры и физику;
написать скрипт управления на C#: читать input, двигать Rigidbody2D, использовать методы Update и FixedUpdate;
обрабатывать столкновения через Collider2D, реагировать на триггеры и собирать «монетки»;
построить простую игровую петлю: старт, набор очков, потеря жизни, Game Over и перезапуск через UI-кнопку;
сделать билд (Build) и протестировать игру вне редактора.

Мы сознательно не уходим в темы, которые могут затянуть первый проект: сложные анимации, продвинутая Input System, сетевой мультиплеер, Cinemachine, шейдеры. Цель — не «игра мечты» на 200 часов, а рабочий прототип, который можно показать друзьям, инвестору или использовать как основу следующего проекта.

2. Мини-дизайн-док: формулируем идею первой Unity 2D игры с нуля

Чаще всего первый проект умирает не из‑за кода, а из‑за отсутствия чёткой идеи. В голове крутится «что-то вроде Subway Surfers, но ещё с базой, крафтом и open-world RPG», и через неделю становится понятно: объём бесконечен, сцена не собирается, enthusiasm закончился. Чтобы этого избежать, полезно потратить 15–20 минут на мини-дизайн-док.

Для первой unity 2d игры оптимальны жанры:

раннер / «уклонялка» — персонаж движется по оси, игрок избегает препятствий; минимум контента, повторяемый геймплей;
простая top-down аркада — вид сверху, движение по двум осям, стрельба или сбор объектов;
микро-платформер — несколько платформ, один тип врага, сбор монет;
головоломка с простыми правилами — движение box-объектов, совпадения по цвету и т.п.

Критерии «подходит новичку»:

мало уникального контента (спрайтов, уровней);
игровой цикл строится на повторении одних и тех же действий;
простая 2D-физика, не нужно изобретать собственную system столкновений.

Шаблон мини-дизайн-документа на одну страницу для нашей «уклонялки» может выглядеть так:

Цель игрока: продержаться как можно дольше, уворачиваясь от препятствий и собирая бонусы. Очки растут за время выживания и собранные объекты.
Основные действия: движение персонажа влево и вправо с помощью стрелок или свайпов; сбор бонусных sprite-объектов; уклонение от опасных объектов.
Условия победы/поражения: победы как таковой нет, есть рекорд. Поражение — столкновение с препятствием (OnCollisionEnter2D / OnTriggerEnter2D) или выход за границы уровня.
Особенности, чтобы игра не была «как у всех»:случайно генерируемые препятствия разной ширины (на уровне настройки BoxCollider2D и скорости);
периодические бонусы замедления time или щита.
Целевая платформа:ПК — управление через клавиатуру, окно 16:9, упор на точность движения;
Android — управление тачем; более крупные объекты и UI-элементы, тестирование под разные разрешения.

На старте можно честно ответить себе на пару вопросов:

Нужен ли звук уже в первом билде? Для обучения нет: достаточно временных звуков из бесплатных библиотек, добавленных позднее.
Нужны ли сложные анимации? На первый проход хватит 2–3 спрайтов: статический персонаж, простое изображение препятствия и бонуса. Анимацию walk/run легко добавить позже.
Где взять временные ассеты (assets)? Подойдут бесплатные пакеты из Unity Asset Store, open-source-наборы спрайтов или даже цветные прямоугольники, созданные прямо в редакторе как Sprite (2D and UI).

Такой короткий документ помогает не расползаться. Если фича не помещается на страницу и не влияет на основную петлю «уклоняйся и собирай», её стоит отложить на «версию 2.0» проекта.

3. Подготовка окружения: установка Unity, выбор версии и создание 2D-проекта

От выбора версии Unity и базовой структуры проекта сильно зависит, столкнётесь ли вы с лишними багами. Для первой игры не нужен cutting edge, важна предсказуемость.

Какую версию Unity выбрать

LTS (Long Term Support) — стабильная ветка, обновляется медленнее, но с прицелом на надёжность. Для 2D-проекта и обучения это лучший выбор.
Tech Stream — свежие фичи, но больше шансов нарваться на регрессии. Имеет смысл, когда уже есть опыт и нужны конкретные новинки.

Для задачи «unity 2d игра с нуля» берите последнюю LTS: в Unity Hub она помечена как LTS и имеет год в названии.

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

Скачайте и установите Unity Hub.
В разделе Installs добавьте new версию Unity (LTS).
При выборе модулей отметьте только то, что реально нужно:

PC, Mac & Linux Standalone — обязательно;
Android Build Support — если планируете билд на телефон;
всё остальное (VR, консоли, WebGL) можно не ставить на старте.

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

В Unity Hub откройте вкладку Projects и нажмите кнопку New.
Выберите шаблон 2D (2D Core или аналогичный) — это сразу задаёт нужные настройки камеры, физики и набора пакетов.
Задайте имя проекта (например, DodgeRunner), путь к папке и нажмите Create.

2D-проект отличается от 3D прежде всего:

камерой: используется ортографическая projection, легче контролировать размер объектов и позицию камеры;
физикой: вы работаете с Rigidbody2D, BoxCollider2D, CircleCollider2D и системой Physics2D;
рендером: спрайты отображаются в плоскости X–Y, ось Z часто используется только для порядка отрисовки.

Базовая структура Assets

Чтобы не утонуть в хаосе, сразу создайте в папке Assets несколько подпапок:

Assets/Scenes — для всех сцен. Сразу сохраните main-сцену как MainScene.unity.
Assets/Sprites — для всех спрайтов и изображений.
Assets/Scripts — для C#-кода.
Assets/Prefabs — для заготовок объектов (препятствия, бонусы, игрок).
Assets/UI — для элементов интерфейса.

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

Нужные пакеты

2D Sprite — базовый набор для работы со спрайтами;
2D Tilemap — пригодится, если решите строить уровни тайлами;
2D Animation — нужен, если захотите анимировать спрайты.

На первом проекте не трогайте URP/HDRP, сложные постэффекты и освещение. Они мало влияют на геймплей, но легко ломают картинку и усложняют отладку.

4. Сборка первой сцены: спрайты, коллайдеры, камера и «ощущение игры»

Создаём основную сцену

Откройте Scene в редакторе (по умолчанию New Scene).
Сразу сохраните её в Assets/Scenes под понятным именем, например MainScene.
Убедитесь, что в сцене есть объект Main Camera и объект EventSystem (для будущего UI).

Одна сцена на старте более чем достаточна: вы сосредотачиваетесь на механике, а не на загрузке уровней.

Добавляем графику

Импортируйте изображения для фона, персонажа и препятствий в папку Assets/Sprites (формат PNG удобнее всего).
Выделите спрайт в инспекторе и настройте:

Sprite Mode = Single (если одно изображение);
Pixels Per Unit — выберите одно значение (например, 100), чтобы масштаб был предсказуемым;
Filter Mode = Point (если нужен «пиксельный» стиль) или Bilinear (для сглаживания).

Перетащите спрайты из Project на сцену — Unity автоматически создаст GameObject с компонентом SpriteRenderer.

Если подходящих спрайтов нет, не останавливайтесь: используйте простые примитивы (Create → 2D Object → Sprite → Square / Circle). Цвет и размер можно настроить прямо в инспекторе.

Строим уровень

Для «уклонялки» достаточно:

фона (один большой sprite или цвет камеры);
невидимых границ слева и справа;
простых платформ/препятствий, которые будут двигаться навстречу игроку.

Быстрый способ сделать пол и стены:

Create → 2D Object → Sprite → Square — получите GameObject с SpriteRenderer.
Переименуйте в Floor, растяните по оси X через Transform → Scale.
Добавьте компонент BoxCollider2D (через Add Component или контекстное меню) — это создаст «твёрдую» поверхность.
Скопируйте этот объект и переместите вверх или по бокам, чтобы сделать границы.

Коллайдеры и физика 2D

Любой объект, который должен участвовать в столкновениях, должен иметь Collider2D. Для нашего уровня это:

BoxCollider2D — для пола, стен и прямоугольных препятствий;
CircleCollider2D — для круглых бонусов (по желанию);
Rigidbody2D — для объектов, которые должны двигаться под действием физики или скрипта.

В режиме Play проверьте, что:

персонаж не проваливается сквозь пол (значит, и у пола, и у персонажа есть корректные collider-компоненты);
препятствия имеют нужный размер box collider — он совпадает с визуальным sprite.

Камера и ощущение сцены

Выберите объект Main Camera и задайте:

Projection = Orthographic;
Size — отвечает за масштаб видимой области (подберите так, чтобы персонаж и препятствия комфортно помещались на экране).

Базовый сценарий — камера следует за игроком по одной оси. Мини-скрипт для камеры:

using UnityEngine; public class CameraFollow : MonoBehaviour { public Transform target; public float smoothTime = 0.2f; private Vector3 velocity = Vector3.zero; void LateUpdate() { if (target == null) return; Vector3 targetPosition = new Vector3(target.position.x, target.position.y, transform.position.z); transform.position = Vector3.SmoothDamp(transform.position, targetPosition, ref velocity, smoothTime); } }

Добавьте этот скрипт как компонент к Main Camera и set-поле target на Transform персонажа. Так вы закрепите «камеры» на игроке и получите базовое «ощущение игры» при движении.

Полезно сразу добавить минимум интерактива: пусть одно препятствие с Rigidbody2D падает сверху. Если всё настроено верно, вы увидите, как объект падает, сталкивается с полом и остаётся лежать — это сигнал, что Physics2D работает правильно.

5. Живой персонаж: управление, скрипты C# и базовая архитектура

На этом шаге вы свяжете воедино объект, компонент, скрипт и поведение — базовый паттерн Unity, который повторяется во всех играх.

Создаём игрового персонажа

Перетащите спрайт персонажа на сцену или создайте placeholder через Create → 2D Object → Sprite → Square.
Переименуйте GameObject в Player, убедитесь, что у него есть SpriteRenderer.
Добавьте Rigidbody2D. В инспекторе:

Body Type = Dynamic;
Gravity Scale — настройте под ваш жанр (для вертикальной уклонялки может быть 0, если не нужна гравитация);
Constraints → Freeze Rotation Z, чтобы персонаж не крутился при столкновениях.

Добавьте BoxCollider2D, отрегулируйте размер под спрайт.

Rigidbody2D отвечает за физику (скорость, массу, силу), Collider2D — за форму столкновения, Transform — за позицию (position), масштаб и вращение.

Где писать код и как его привязать

В папке Assets/Scripts создайте C# Script с именем PlayerController (через Create → C# Script).
Перетащите скрипт на объект Player — Unity автоматически добавит его как компонент на GameObject.
Дважды кликните по скрипту, чтобы открыть IDE (Visual Studio, Rider или VS Code). Внутри вы увидите базовый шаблон:

using UnityEngine; public class PlayerController : MonoBehaviour { void Update() { } }

MonoBehaviour (monobehaviour) — базовый класс Unity, от которого наследуется почти любой скрипт. Через него вы получаете доступ к жизненному циклу объекта: методы Start, Update, FixedUpdate, OnCollisionEnter2D и т.п.

Простое управление: двигаем персонажа

Для новичка проще всего использовать старую систему ввода (Input.GetAxis), а не новый Input System package. Пример скрипта движения влево-вправо:

using UnityEngine; public class PlayerController : MonoBehaviour { public float moveSpeed = 5f; private Rigidbody2D rb; private float moveInput; void Awake() { rb = GetComponent<Rigidbody2D>(); } void Update() { moveInput = Input.GetAxis(«Horizontal»); } void FixedUpdate() { Vector2 velocity = rb.velocity; velocity.x = moveInput * moveSpeed; rb.velocity = velocity; } }

Обратите внимание на следующие моменты:

using UnityEngine; — директива, подключающая пространство имён Unity;
Update вызывается каждый кадр и подходит для чтения ввода (input);
FixedUpdate вызывается с фиксированным шагом time и используется для работы с физикой и Rigidbody2D;
public поля (moveSpeed) видны в инспекторе, их удобно настраивать без правки кода;
private поля (rb, moveInput) скрыты и используются только внутри скрипта.

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

Столкновения и взаимодействия

Чтобы игрок мог собирать бонусы и умирать от препятствий, понадобится реакция на события физики. Пример:

public class PlayerController : MonoBehaviour { public int lives = 1; public int score = 0; void OnTriggerEnter2D(Collider2D other) { if (other.CompareTag(«Bonus»)) { score += 10; Destroy(other.gameObject); } if (other.CompareTag(«Obstacle»)) { lives—; if (lives <= 0) { FindObjectOfType<GameManager>().GameOver(); } } } }

Чтобы это работало, у бонусов и препятствий должны быть Collider2D-компоненты с опцией Is Trigger (иначе вызовется OnCollisionEnter2D). Теги (Tags) Bonus и Obstacle задаются в инспекторе для каждого объекта или prefab.

Мини-архитектура: не делайте «бог-скрипт»

Частая ошибка первой игры — один огромный скрипт, который контролирует всё: движение, спавн препятствий, UI, сохранения. Его тяжело читать, править и расширять. Лучше с самого начала минимально разделить ответственность:

PlayerController — отвечает только за движение игрока и базовые реакции на столкновения;
GameManager — управляет состояниями игры (Playing, GameOver), хранит счёт и жизни, пересоздаёт сцену при перезапуске;
UIController — обновляет текстовые поля (score, best score), показывает/скрывает панель Game Over;
ObstacleSpawner — раз в заданный промежуток time создаёт новые препятствия (через Instantiate prefab).

Простейший скрипт GameManager может выглядеть так:

using UnityEngine; public class GameManager : MonoBehaviour { public static GameManager Instance; public int score = 0; public bool isGameOver = false; void Awake() { if (Instance == null) { Instance = this; DontDestroyOnLoad(gameObject); } else { Destroy(gameObject); } } public void AddScore(int amount) { if (isGameOver) return; score += amount; } public void GameOver() { isGameOver = true; // показать UI Game Over, остановить спавн препятствий } public void Restart() { UnityEngine.SceneManagement.SceneManager.LoadScene(«MainScene»); } }

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

Как понять, что ваш код «достаточно хороший»

Скрипты короткие (20–80 строк), у них понятные имена и одна понятная задача.
Вы не боитесь удалить компонент и добавить его снова, потому что понимаете, как он связан с объектом.
Нет ощущения «если я трону эту строчку, всё сломается» — значит, логика избыточно переплетена.

На первом проекте можно не переживать из‑за отсутствия паттернов вроде MVC или ECS. Гораздо важнее довести сцену до играбельного состояния, чем получить «идеальный» код.

6. Игровая петля: очки, жизни, UI и перезапуск игры

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

Определяем петлю для нашей «уклонялки»

Старт: игрок появляется в центре экрана, счёт = 0, жизни = 1.
Игра: препятствия появляются сверху и движутся вниз, игрок уклоняется и собирает бонусы, счёт растёт.
Событие конца: столкновение с опасным объектом или выход за границы — Game Over.
Перезапуск: по кнопке Restart сцена перезагружается, всё начинается заново.

Счёт и прогресс

Счёт можно увеличивать:

за каждую собранную монету/бонус;
за время выживания (например, +1 очко каждые 0.5 секунды);
за пройденное расстояние (в вертикальном раннере это фактически то же время).

Хранить счёт удобно в GameManager, а PlayerController и ObstacleSpawner просто вызывают AddScore. UI-текст счёта обновляется каждый раз при изменении score.

Жизни и Game Over

Самый простой вариант — одна жизнь. При касании препятствия игрок умирает, игра переходит в состояние Game Over:

игровой ввод блокируется;
спавн препятствий останавливается;
открывается панель с текстом «Game Over» и кнопкой Restart.

Простой UI: Canvas, текст и кнопка

Создайте UI Canvas (Create → UI → Canvas). Он автоматически добавит EventSystem, если его ещё нет.
Внутри Canvas создайте Text (TextMeshPro или обычный Text) для отображения счёта.
Создайте Panel для экрана Game Over, внутри неё Text и Button Restart.
Разместите элементы так, чтобы они хорошо выглядели в разных разрешениях (Anchor в RectTransform помогает закрепить элементы относительно углов или центра экрана).
Напишите простой UIController-скрипт, который:

подписывается на события GameManager (изменение счёта, Game Over);
обновляет текстовые поля;
обрабатывает нажатие кнопки Restart и вызывает GameManager.Restart().

Сохранения по минимуму

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

int bestScore = PlayerPrefs.GetInt(«BestScore», 0); if (score > bestScore) { PlayerPrefs.SetInt(«BestScore», score); PlayerPrefs.Save(); }

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

7. Отладка, сборка и первые шаги к публикации

Даже в небольшом прототипе легко столкнуться с багами, особенно связанными с физикой и input. Важно не пугаться красных сообщений в Console, а использовать инструменты Unity осознанно.

Типичные баги первой Unity 2D игры

Персонаж проваливается сквозь пол. Проверьте:
есть ли у пола компонент Collider2D (BoxCollider2D);
есть ли у персонажа Collider2D и Rigidbody2D;
находятся ли объекты в одном слое (Layer) или настроены ли Layer Collision Matrix.
Камера уезжает в никуда. Чаще всего забыли задать target у CameraFollow или уничтожили объект, за которым камера должна следить. Проверьте поле target в инспекторе.
Объекты не реагируют на столкновения. Возможные причины:
используете OnCollisionEnter2D, но включён Is Trigger, нужен OnTriggerEnter2D;
скрипт висит не на том объекте или метод написан с ошибкой в имени (OnCollisionEnter2D чувствителен к регистру);
у обоих объектов нет Rigidbody2D (для событий достаточно одного, но хотя бы один должен быть).
Управление работает по-разному на разных FPS. Это признак, что вы изменяете transform.position в Update без учёта Time.deltaTime или лезете в физику из Update вместо FixedUpdate.

Инструменты отладки

Console — показывает ошибки (Error), предупреждения (Warning) и сообщения (Log). Дважды кликните по ошибке, чтобы перейти к строке кода.
Debug.Log — быстрый способ проверить, вызывается ли код: Debug.Log(«Hit obstacle » + other.name);
Gizmos — позволяют визуализировать границы, лучи, зоны спавна прямо в Scene view.
Инспектор в режиме Play — можно смотреть текущие значения полей скриптов, Rigidbody2D velocity, position и менять настройки на лету.

Сборка билда

Откройте File → Build Settings.
Нажмите Add Open Scenes, чтобы добавить MainScene в список.
Выберите целевую платформу (PC, Android) и нажмите Switch Platform.
В Player Settings задайте:

Company Name и Product Name — они попадут в метаданные билда;
Resolution and Presentation — стартовое разрешение и полноэкранный режим;
Icon — при желании можно поставить простое изображение.

Нажмите Build, выберите папку (например, Builds/PC), set имя файла и дождитесь завершения.

Получившийся exe-файл (или apk для Android) можно перенести на другой компьютер или устройство и протестировать игру вне редактора, оценить скорость, управление и реакцию игроков.

Публикация «для друзей»

Для ПК-билда удобно использовать itch.io — вы просто загружаете архив и получаете страницу с игрой.
Мобильную apk можно отправить в мессенджере или выложить в закрытый раздел сайта.

Попросите 3–5 человек поиграть и ответить на несколько конкретных вопросов:

понятна ли цель игры и управление без объяснений;
что показалось скучным через 1–2 минуты;
в какой момент они перестали играть и почему.

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

8. Когда стоит подключать команду и во что может вырасти ваш прототип

Создав unity 2d игру с нуля самостоятельно, вы получаете больше, чем кажется:

практическое понимание, как устроены сцены, GameObject, компоненты, как работает Transform и Camera;
язык общения с разработчиками: вы уже знаете, что такое скрипт на C#, rigidbody, collider, input system, как устроены assets и что значит «настроить камеру»;
реальный прототип, на котором можно проверять гипотезы: геймдизайнерские, маркетинговые, монетизационные.

Профессиональная команда имеет смысл, когда:

вы хотите мобильную версию с монетизацией, аналитикой, авторизацией, интеграцией с бэкендом, CRM или веб-сервисом;
игра «зашла» внутри компании или комьюнити и её нужно превратить в продукт с масштабируемой архитектурой, нормальным артом, звуком и UI;
нужны сетевые режимы, сложная внутриигровая экономика, связка игры с сайтом, интернет-магазином или внутренней системой компании.

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

довести ваш Unity-прототип до продакшн-уровня: оптимизация, переработка кода, настройка сборочного pipeline;
адаптировать игру под Android, iOS и веб, связать её с существующей системой (CRM, сайт, магазин);
взять на себя полный цикл: от уточнения дизайн-документа и создания спрайтов до релиза и поддержки.

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