Создание 2D игры на Unity: пошаговое руководство с примерами

Главная
Блог
Создание 2D игры на Unity: пошаговое руководство с примерами

Unity продолжает удерживать лидирующие позиции среди движков для разработки 2D игр благодаря своей мультиплатформенности, обширному магазину ассетов и нативной поддержке работы со спрайтами. Он предоставляет готовые компоненты и визуальные редакторы, которые упрощают прототипирование и позволяют сразу сосредоточиться на игровом процессе, не тратя недели на «кулисы». В этом материале — конкретное, пошаговое руководство: от идеи до работающего платформера, который можно пересобрать под Android или Web прямо с одного проекта.

Подготовка: выбор идеи и технической базы

Прежде чем открывать Unity, определитесь с жанром. Не все 2D концепции одинаково жизнеспособны. На старте рекомендуются:

Платформер — решает задачи по физике, уровневому дизайну, анимации.
Пазл — фокус на интерфейсе и правилах, минимальная механика.
Top-down экшн или shooter — интересен взаимодействием и таймингом.
Roguelike — используется системой генерации, актуален для практики прогрессии.

Проверьте свою идею по важному принципу: зависит ли геймплей от камеры? Если управляемая перспектива (вращения, перспективы) влияет на механику — вероятно, нужен 3D. Если достаточно проекции сверху или сбоку — 2D вполне подойдет.

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

Набор ассетов: спрайты персонажа, фоны, объекты, враги. Источник — Unity Asset Store, Kenney, itch.io.
Схема управления: определите, что делает каждая кнопка. Всего пара действий — хорошее ограничение.
Геймплейная схема: простая диаграмма (на бумаге, Figma или Miro), описывающая действия игрока и результат: «персонаж идет → собирает предмет → получает очки».

Дополнительно стоит установить:

Редактор для спрайтов (Aseprite, Piskel, Photoshop) — если нужно подогнать изображение или сделать анимации.
Редактор тайлмапов (Tiled) — при необходимости создавать уровни в стиле Zelda или Terraria.

Такое планирование на уровне фундамента предотвращает 80% типичных ошибок — лишние действия, нецелевые ассеты, управление не в тему. Зафиксируйте эти вводные в отдельной папке проекта (например, Docs/Design) и двигайтесь к сцене.

Первый проект: настройка среды и базовая сцена

Запустите Unity Hub и создайте новый проект. При выборе шаблона обязательно выберите «2D» — это активирует камеру без перспективы (orthographic) и оптимизированные шейдеры.

Настройка проекта:

Resolution: в Edit → Project Settings → Player → Resolution and Presentation зафиксируйте предпочтительное разрешение. Для мобильных — 720×1280 (portrait) или 1920×1080 (landscape).
Камера: установите Orthographic размер (Size) = 5 — это среднее значение, которое можно адаптировать под спрайты.
Color Space: Linear, если планируете динамическое освещение. Иначе оставьте Gamma.
Script Backend: IL2CPP — особенно важно для Android, где Mono менее стабилен.

После этого создайте базовую сцену, которую затем будете дополнять:

Создайте объект фона (GameObject → UI → Image или Sprite): установите ваш фон (BG.png) как Sprite Renderer, масштабируйте под камеру.
Импорт ассетов в папку Assets: создайте директорию Assets/Sprites и перетащите туда изображения. Для каждого изображения в Inspector установите Sprite (2D and UI) и активируйте Pixel Perfect (если важен пиксель-арт).
Создайте персонажа: GameObject → 2D Object → Sprite → выберите изображение героя (например, player_idle.png). Назовите его Player. Добавьте компоненты: Rigidbody 2D (Gravity Scale 3) и BoxCollider2D.

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

Контроль версий:

Если проект один — Unity Collaborate подойдёт. Активируйте из меню Services → Collaborate.
Для команды — используйте Git и .gitignore (Unity генерирует специфические метаданные, не все их стоит версионировать).

Хорошая практика — сохранить первый коммит как init commit (scene setup + camera), даже если вы в соло. Это создаёт точку отсчёта и позволяет откатиться безболезненно.

Ваша сцена может состоять буквально из четырех объектов — и уже быть готовой к начальной логике.

Работа с персонажем: физика, анимация, управление

После настройки персонажа, переходите к поведению. Для базового движения достаточно четырёх элементов: Rigidbody2D, Collider2D, Input, Animator. Их настройка — залог отзывчивости и предсказуемости контролов.

Физика и столкновения:

Добавьте Rigidbody2D на GameObject Player. Gravity Scale: 3 подходит для «чувства массы», Interpolate: Interpolate (улучшает плавность).
Добавьте BoxCollider2D. Убедитесь, что он плотно прилегает к спрайту (можно вручную натянуть гизмо-сетку).

Обработка движения:

Создайте новый C# скрипт PlayerMovement.cs и привяжите к объекту Player. Простейшее движение:


public class PlayerMovement : MonoBehaviour {
    public float speed = 5f;
    public float jumpForce = 7f;
    private Rigidbody2D rb;

    void Start() {
        rb = GetComponent<Rigidbody2D>();
    }

    void Update() {
        float move = Input.GetAxis("Horizontal");
        rb.velocity = new Vector2(move * speed, rb.velocity.y);

        if (Input.GetButtonDown("Jump") && Mathf.Abs(rb.velocity.y) < 0.001f) {
            rb.AddForce(new Vector2(0, jumpForce), ForceMode2D.Impulse);
        }
    }
}

Такой скрипт работает сразу, и вам не нужны Event Trigger или отдельный Input System. Однако, стоит обновить Input под управление геймпадом или сенсором, если Android в приоритете.

Анимация:

Создайте анимации: например, player_idle.anim, player_run.anim, player_jump.anim.
Создайте новый компоненты Animator и Animation на объекте Player.
Создайте новый Animator Controller (Assets/Animations/PlayerAnimator) и привяжите к Player.

Переходы между состояниями (idle → run → jump) задаются через Triggers и Parameters. Вариант для перехода: если скорость по X больше 0.2 — запускаем Run, иначе Idle. Прыжок — по событию Down Jump.

Плохие практики, которых стоит избежать:

Непосредственная правка позиции объекта (transform.position): ломает физику, рывки.
Прыжки без ограничения двойного прыжка: побочный эффект, персонаж «взлетает».
Безопасная логика: используйте флаги Grounded через Raycast или отдельный Collider снизу — это позволяет корректировать прыжки.

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

Качественные движения — ключ к «играбельности». Даже базовый визуал, но с управлением уровня Celeste, способен вовлечь пользователя на часы. Проверьте: движения отзывчивы, прыжок запускается не позже, чем через 0.05 сек после нажатия, нет эффекта «пластилинового» слайдинга.

Создание игрового окружения: уровни, тайлы, взаимодействие

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

Настройка Tilemap:

Создайте новый Tilemap через GameObject → 2D Object → Tilemap → Rectangular.
Unity автоматически создаст объект Grid и вложенную в неё Tilemap + TilemapRenderer. Назовите Tilemap «Ground».
Откройте Window → 2D → Tile Palette. Создайте новую палитру (например, “MainTiles”) и сохраните в Assets/TilePalettes.
Перетащите свои спрайты-тайлы в палитру. Unity предложит превратить их в Tile-объекты (.asset).
Выберите тайл и кистью нарисуйте платформы прямо в сцене, как в графическом редакторе.

Чтобы персонаж «стоял» на тайлах — добавьте компонент Tilemap Collider 2D на Tilemap. Для оптимизации желательно добавить к нему Composite Collider 2D и установить Tilemap Collider → Used By Composite = True. Это уменьшает количество коллайдеров на сцене и повышает производительность.

Масштабирование и пиксельный масштаб:

Если работаете со спрайтами 16×16 или 32×32, проверьте, что PPU (pixels per unit) совпадает с остальными объектами. Несоответствие приведет к размытости и багам коллизий.

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

Collectibles (монеты, предметы): создаются как отдельные объекты Sprite + Collider2D (Trigger). На OnTriggerEnter2D вы вызываете подсчет очков и уничтожаете объект (Destroy(gameObject)).
Движущиеся платформы: используйте Rigidbody2D (Kinematic) и задайте траекторию через анимацию или скрипт-фреймворк (например DOTween).
Враги: NPC с коллайдерами, Mesh Renderer и простым патрулированием. При столкновении с игроком — уменьшение жизней или перезапуск уровня.

Частые ошибки при работе с Tilemap:

Ручное наложение спрайтов поверх тайлов: приводит к путанице по слоям, их сложно сортировать.
Отсутствие Sorting Layers: фон может перекрывать персонажа, если не настроен правильный порядок отрисовки.
Тени и освещение: если используются Light 2D компоненты — убедитесь, что все тайлы в правильной Sorting Layer и Render Layer (Sprite Renderer → Additional Settings).

Порядок разработки сцен:

На старте стоит ограничиться одной-двумя тест-сценами: «уровень» и «геймплейная песочница». Это снижает нагрузку, позволяет быстро тестировать фичи и не приводит к «туннельной разработке», где вы строите 20 уровней, но не имеете игровой логики. Каждая сцена сохраняется отдельно (File → Save as) в /Scenes, их можно подгружать через SceneManager.LoadScene().

Базовая логика игры: очки, столкновения, экран смерти

Функциональность — это не только движение. Даже в прототипе уместно реализовать базовую игровую логику: сбор очков, смерть персонажа, обработку UI и завершение уровня. В Unity всё это делается элементарно через скрипты и события компонентов.

UI: отображение очков и здоровья

Откройте GameObject → UI → Canvas. Установите Render Mode: Screen Space — Camera (привяжите MainCamera).
Добавьте Text UI элемент (TextMeshPro или обычный): назовите «ScoreText». Разместите справа сверху.
Создайте скрипт GameManager.cs и добавьте к отдельному пустому объекту. В нем храните игровой прогресс:


public class GameManager : MonoBehaviour {
    public int score = 0;
    public Text scoreText;

    public void AddScore(int value) {
        score += value;
        scoreText.text = "SCORE: " + score;
    }
}

Свяжите UI через drag-n-drop в инспекторе. Каждый предмет при сборе будет вызывать FindObjectOfType<GameManager>().AddScore(1).

Смерть игрока:

Создайте объект с тегом «Hazard» (например, шипы или враг).
Если у него Collider2D isTrigger = true, то в скрипте персонажа можно реализовать:


void OnTriggerEnter2D(Collider2D collision) {
    if (collision.CompareTag("Hazard")) {
        UnityEngine.SceneManagement.SceneManager.LoadScene(0); // перезагрузка текущей сцены
    }
}

Использование UnityEvents:

Замените статический вызов GameManager на UnityEvent, который можно повесить через инспектор. Это создаст слабую связанность и сократит баги с null-ссылками.


[System.Serializable]
public class ScoreEvent : UnityEngine.Events.UnityEvent<int> { }

public class Collectible : MonoBehaviour {
    public ScoreEvent onCollected;

    void OnTriggerEnter2D(Collider2D other) {
        if (other.CompareTag("Player")) {
            onCollected.Invoke(1);
            Destroy(gameObject);
        }
    }
}

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

Локальные скрипты vs Менеджеры:

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

Также не спешите абстрагировать код в классы, пока не повторяются хотя бы 2–3 раза. Иначе вы теряете драгоценное время в «золочении архитектуры». Unity хорош тем, что позволяет быстро склеить MVP — используйте это.

Построение и экспорт: запуск на ПК, Android, WebGL

Когда основная механика реализована — пора собрать первый билд. Unity позволяет запускать один и тот же проект на Windows, Android, iOS, WebGL, консолях. На первых порах целесообразно поддерживать хотя бы 2 платформы: Windows (для теста) и Android/WebGL.

Build Settings:

Откройте File → Build Settings.
Добавьте текущую сцену («Add Open Scenes»).
Выберите платформу: ПК (PC, Mac & Linux), Android или WebGL.
Нажмите Switch Platform — Unity пересоберёт проект под выбранную платформу.

Особенности экспорта:

Android: установите Android Build Support в Unity Hub. Проверьте Player Settings → Other Settings: установлен API Level 19+, минимальное разрешение 720p. При использовании картинки — избегайте неиспользуемых PNG >1MB, это снижает производительность.
WebGL: отключите любые ссылки на файловую систему. Canvas должен быть оптимизирован, avoid прозрачность UI без надобности. Включите Compression (Gzip).

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

Window → Analysis → Profiler.
Открывайте вкладку Rendering и Memory. Ищите узкие места: большой Draw Call, CPU spikes, длинный GC (генерация мусора).
Оптимизируйте: выключайте объекты за пределами экрана, объединяйте спрайты, сокращайте коллайдеры.

Даже простая игра теряет 30–40 FPS на слабых Android, если используется множество сложных анимаций, неотрендеренные Canvas или слишком богатый фон. Используйте Sprite Atlas и Batching.

Разбор примера: простой 2D платформер на Unity с GitHub

Чтобы ускорить старт и закрепить материал — изучите готовый пример мини-игры. В нём реализованы основные элементы: сцена с платформами, управление персонажем, сбор объектов, минимальный интерфейс. Этот шаблон можно адаптировать под собственную механику за один вечер.

GitHub-репозиторий: https://github.com/yourusername/simple-2d-platformer-unity

Что реализовано в проекте:

Персонаж с анимацией передвижения, прыжка и простым контроллером.
Сцена, построенная через Tilemap, с фоном, коллайдерами и платформами.
Собираемые объекты (монетки), каждый из которых добавляет очки.
UI-интерфейс с отображением очков и текста «Game Over».
Загрузка сцен и перезапуск уровня при смерти.

Этот репозиторий можно использовать как:

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

Как можно развить проект:

Добавить врагов с разными паттернами поведения (движение, поиск игрока).
Реализовать прогрессию: навыки, способности, дополнительное оружие.
Сделать «мета-слой»: меню улучшений, выбор уровней, лут.
Настроить саунд-дизайн: звуки прыжков, музыки, поражения.
Запись очков и finest time прохождения через PlayerPrefs / JSON-файлы.

Важно понимать: начать простую 2D игру — это не упрощение, а стратегическое решение. Даже успешные инди-хиты, вроде Celeste, Hollow Knight или Dead Cells, строились вокруг базовых 2D-прототипов, дорабатываемых на протяжении месяцев. Ваша цель — создать версию, которую приятно трогать уже на 5-м часу разработки.

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

Итоговый призыв к действию

Хотите превратить идею в работающую игру — мы поможем. Наша команда создаёт прототипы, продумывает геймдизайн и доводит проект до релиза в App Store / Google Play / WebGL. Закажите разработку под вашу механику — мы подключимся на любом этапе и гарантируем техническую чёткость и игровую отзывчивость.