Чистая архитектура на Unity [Тариф Полный курс с куратором] [Евгений Шилов]

Топикстартер · 14 фев 2026

Складчина: Чистая архитектура на Unity [Тариф Полный курс с куратором] [Евгений Шилов]

Что ты получишь на курсе

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

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

Создашь законченный продукт и доведёшь его до релиза
В процессе курса ты разработаешь игру, выложишь её на Яндекс.Игры. В неё поиграют живые люди, а ты получишь реальный пользовательский фидбэк.

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

Сможешь применять те же принципы в 1С-проектах
Курс не про синтаксис конкретного языка, а про то, как правильно строить архитектуру приложений. Мы практикуемся на C#, потому что классы и интерфейсы делают структуру чистой архитектуры наглядной: проще увидеть, где должна жить логика и как отделить её от UI и внешних подключений. После курса ты сможешь применять тот же подход в 1С, только часть договорённостей и границ придётся выражать не "конструкциями языка", а дисциплиной и правилами разработки.

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

Программа:

Организационный модуль: настройка рабочего окружения

Основы Unity: редактор, компоненты, MonoBehaviour и префабы

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

Чистая архитектура: требования, слои и ответственность

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

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

Базовые системы игры: настройки, баланс, сохранения

Чистый UI на Unity

Работа с SDK Яндекс Игры

Оптимизация WebGL: производительность и размер билда

Публикация в Яндекс Играх: карточка, обложка и тексты

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

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

Результаты:

установите и настроите Unity, Rider и Git в нужных версиях так, чтобы всё стабильно работало вместе

создадите первый проект и проверите полный цикл: открыть → написать/изменить код → запустить → увидеть результат

освоите базовые команды Git: коммиты, ветки на базовом уровне, отправка/получение изменений

подключите правильный .gitignore для Unity и поймёте, что именно нужно/не нужно хранить в репозитории

разберётесь, что такое Git LFS, зачем он нужен в Unity-проектах и как его подключать

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

2. Основы Unity: редактор, компоненты, MonoBehaviour и префабы

В этом модуле вы освоите базовую механику работы в Unity: как устроен редактор и сцена, как добавлять и организовывать объекты, как работает модель GameObject–Component, как подключать поведение через MonoBehaviour-скрипты. Отдельно разберём префабы как способ ускорять разработку и поддерживать порядок в проекте, а также сделаем минимальный UI, чтобы отображать данные и видеть результат работы прямо на экране.

Результаты:

уверенно ориентируетесь в Unity Editor и понимаете структуру сцены

создаёте объекты на сцене и настраиваете их через компоненты

подключаете и редактируете поведение через MonoBehaviour-скрипты и Инспектор

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

выводите простые элементы UI (текст/число/картинка) для визуализации результата

3. Инженерная гигиена Unity: зависимости, инициализация, цикл кадра, корутины

В Unity многие проблемы начинаются не с "логики", а с того, как объекты и классы связаны друг с другом. В этом модуле мы разберём базовые понятия, которые часто непривычны 1С-разработчикам: что такое зависимость (когда один класс использует другой), почему синглтоны (по сути "общие модули" в 1С) со временем мешают, и зачем нужна единая точка запуска (Bootstrap). Параллельно разберём гонку инициализации (когда один объект обращается к другому до того, как тот готов), посмотрим, в каком порядке Unity выполняет код внутри кадра, и затронем корутины и события.

Результаты:

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

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

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

понимать, почему синглтоны (по сути "общие модули" в 1С) часто приводит к запутанным связям и усложняет развитие проекта

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

4. Чистая архитектура: требования, слои и ответственность

Разбираем чистую архитектуру на практике в Unity: что такое слои, как распределять ответственность и почему зависимости должны быть направлены "к центру". Учимся проектировать не от экранов и кнопок, а от сценариев использования — что должно произойти, какие правила сработают и какой результат получим. Параллельно выстраиваем понятный путь выполнения: внешнее событие фреймворка (Unity/1С) запускает сценарий через тонкую "прослойку", а результат уходит в презентер и дальше в отображение (экран/UI).

Результаты:

понимаете, что такое бизнес-логика, и где ей место в проекте

перестаёте строить систему "от экранов и кнопок" и начинаете строить её от сценариев использования

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

отделяете правила и смысл продукта от "обвязки" (UI, база, фреймворк, внешние сервисы) — изменения перестают разносить проект

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

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

понимаете базовые понятия SOLID

5. Проектирование домена и сборка проекта

Это самый сложный и самый важный кусок: проектируем домен — правила, без которых игра/продукт "невалиден" и начинает ломаться. У Роберта Мартина это называется сущностями (entities): он подчеркивает, что это ключевая часть системы, но почти не объясняет, как именно ее проектировать. Поэтому мы берём DDD как практичный способ моделировать домен без лишних усложнений и учимся правильно "собирать" систему через точку сборки (Bootstrap) и передачу зависимостей.

Результаты:

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

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

применяете DDD как инструмент проектирования домена и берёте только то, что реально помогает, без усложняющих практик

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

прокидываете зависимости через Dependency Injection (DI) понятными способами — в первую очередь через конструктор и параметры, а не через Инспектор

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

6. Придумываем игру: от идеи к плану релиза

В этом модуле вы придумаете идею небольшой игры, которую реально довести до релиза на Яндекс Игры (WebGL). Разберём, почему инди-игры можно делать в одиночку и на них можно зарабатывать, почему нельзя стартовать "с белого листа", и как правильно вдохновляться другими играми: выбрать референсы, разобрать их механики и собрать свою концепцию. В конце вы оформите идею в понятные документы, спланируете путь до минимальной играбельной версии (вертикального среза) и защитите свою игру перед группой.

Результаты:

выбранная ниша/жанр и понимание для кого вы делаете игру (а значит — что в ней должно быть)

1–3 референса и разбор их механик: что берём, что меняем, что выкидываем

одностраничное описание игры: о чём игра, в чём кайф, для кого, как поймём по цифрам, что работает

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

чёткий план задач до вертикального среза в трекере (чаще всего в Яндекс Трекер): что делаем по шагам и в каком порядке

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

навык короткой публичной защиты: вы умеете объяснить идею за несколько минут и уверенно отвечать на вопросы

7. Базовые системы игры: настройки, баланс, сохранения

Продолжаем работать с чистой архитектурой по Роберту Мартину. Но теперь на примере базовых систем, которые нужны почти в любой игре. Разбираем, как правильно хранить настройки и "статические данные" через ScriptableObject (формат хранения данных/настроек в Unity), как организовать спавн объектов по меткам на сцене и как связать это с бизнес-логикой, не затаскивая Unity-объекты внутрь. Отдельный большой блок — сохранения (мета-прогресс и прогресс уровня), и как всё это встроить в проект чисто.

Результаты:

встроите в свой core базовые системы, которые встречаются почти в каждой игре: данные/настройки, спавн, пауза, сохранения

научитесь хранить настройки и статические данные через ScriptableObject и получать их в логике "чисто", через правильные границы

организуете спавн по "меткам" на сцене: на уровне остаётся статика, а всё, чем управляет код, появляется через понятную систему спавна

сделаете единый Unity Loop — одно место, откуда запускается логика кадра, чтобы core-логика не расползалась по десяткам MonoBehaviour

поймёте, как связывать несколько сценариев использования между собой аккуратно, без "лапши"

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

еще раз закрепите подход Роберта Мартина на практике: каждый из этих элементов выстраивается через чистые границы и понятные зависимости

8. Чистый UI на Unity

В этом модуле вы учитесь проектировать и собирать UI так, чтобы он был понятным и управляемым — не только в Unity, а в целом как подход. Разберём, какие типы экранов и окон бывают в играх и приложениях, кто и как должен ими управлять, и как заранее спроектировать переходы между экранами через UI-flow — простую схему "куда можно попасть и откуда". Всё делаем через призму чистой архитектуры по Роберту Мартину: чёткие зоны ответственности и понятная граница между UI и бизнес-логикой.

Результаты:

спроектируете UI-flow своей игры: какие экраны есть и как пользователь между ними переходит

реализуете менеджер окон: стек окон, модальные/немодальные окна, блокировка ввода, обработка нажатия клавиши Esc

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

научитесь отличать ситуации, когда сценарий использования не нужен (чисто UI-переход), и когда он обязателен (есть логика, правила, данные)

сделаете обязательные UI-части: HUD, пауза, экран загрузки, попапы/нотификации

9. Работа с SDK Яндекс Игры

Интегрируем SDK Яндекс Игры в Unity вручную, без сторонних пакетов: правильно инициализируем SDK, отправляем "игра загрузилась", обрабатываем паузу/возврат в игру и подключаем rewarded-рекламу. Настраиваем WebGL HTML-шаблон и делаем двустороннюю связь: Unity может вызывать SDK, а SDK — присылать события обратно. Все строим по принципам чистой архитектуры Роберта Мартина, чтобы платформенная интеграция не ломала бизнес-логику.

Результаты:

рабочая базовая интеграция SDK: корректная инициализация, сигнал "игра готова", обработка паузы и показ rewarded-рекламы

"правильный" WebGL HTML-шаблон под площадку: подключение скриптов, порядок инициализации, размеры и фокус

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

интеграция, изолированная от бизнес-логики: добавлять новые методы SDK можно без переписывания бизнес-логики

режим разработки и тестирования: локальный запуск + заглушка SDK для проверки поведения без публикации

навыки отладки WebGL-интеграций: дебаг-панель площадки и браузерные DevTools (консоль, сеть, breakpoints)

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

10. Оптимизация WebGL: производительность и размер билда

Делаем так, чтобы WebGL-игра не просто "запускалась", а работала плавно и быстро загружалась. Учимся находить и устранять микрофризы, понимать, где узкое место — в логике, отрисовке кадра или памяти. Уменьшаем размер билда под Яндекс Игры: разберём настройки сборки и сжатия, чтобы игра стартовала быстрее и лучше проходила по требованиям площадки.

Результаты:

умеете диагностировать микрофризы и просадки FPS и отличать проблемы логики (CPU/GC) от проблем рендера (GPU)

владеете набором инструментов для WebGL-профилирования: Unity Profiler, Performance в DevTools, Frame Debugger, счетчик FPS внутри игры

научитесь проверять релизное поведение: профилировать сборку в браузере и подключать профилирование к своему локальному веб-серверу

понимаете, что именно "съедает кадр", и умеете находить тяжёлые места в коде, которые приводят к лагам и сборкам мусора

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

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

11. Публикация в Яндекс Играх: карточка, обложка и тексты

В этом модуле вы доводите игру до "публикуемого" состояния: проверяем технические требования площадки (пауза, загрузка, реклама, размер и производительность, корректное поведение в браузере), собираем материалы для карточки и отправляем игру на модерацию. Ключевая идея — ChatGPT закрывает всё оформление: делает тексты, собирает обложку и иконку и выдает сценарии для скриншотов и видео.

Результаты:

проверите игру по ключевым требованиям Яндекс Игры: пауза, загрузка, реклама, размер/производительность, поведение при сворачивании/возврате

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

сделаете цепляющую обложку и иконку через нейросети: разберёте критерии "хорошо/плохо" и получите рабочий результат для публикации

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

соберёте набор скриншотов из реального геймплея по "сценарию кадров" от ChatGPT и при необходимости доработаете их в нейросетях (например, убрать лишний UI)

подготовите сценарий для короткого видео (по желанию) — так, чтобы оно цепляло с первых секунд

разберётесь с базовыми правилами модерации по контенту и правам: что нельзя использовать (чужие бренды/материалы) и что точно вызовет вопросы

Тариф Полный курс с куратором

Все модули программы: от основ до публикации на Яндекс.Играх

Цена 74900 руб.
Скрытая ссылка