Unity Adventure. Научись делать игры на Unity с нуля (2025) [Илья Яковлев]

Складчина: Unity Adventure. Научись делать игры на Unity с нуля (2025) [Илья Яковлев]

а 6.5 месяцев ты полностью освоишь программирование на языке C#, разберешься с работой над 2D и 3D проектами в движке Unity, научишься проектировать игровые системы, и закончишь курс полноценным сложным проектом!

• Программирование с нуля
  Начнем изучение разработки игр с нуля и дойдем до проектирования целой игры. Формат отлично подойдет как для тех, кто еще не дорос до уровня juniour, так и для желающих восполнить и структурировать все необходимые знания
• Практика
  Вас ждут как домашние задания с развернутым фидбеком, так и живые обсуждения возникающих трудностей. Все обучение направлено на отработку полученных знаний в движке
• Видеозаписи
  Все уроки разделены на небольшие лекции для удобного усвоения материала. Кроме того, доступ к платформе останется у вас даже после окончания курса, поэтому к урокам можно будет вернуться позже

Кратко о курсе
Курс структурирован так, чтобы дать полную базу по С#, начиная с базового и заканчивая продвинутым уровнем, при этом отрабатывая все на практике в Unity.
Результат будет достигаться путем изучения теории, реализации игровых механик и полноценных проектов на Unity.
Весь курс поделен на четкие логические блоки и совмещает в себе изучение языка, работу в движке, а также получение дополнительных знаний в
виде необходимой базы по математике, дополнительным инструментам, используемым при разработке игр, системы контроля версий и др.
Кроме того, особенностью данного курса является создание финальной полноценной игры, на которой мы сможем применить все полученные
знания для структурированной организации работы проекта, изучим довольно сложные, но необходимые концепции при проектировании
игры, такие как внедрение зависимостей, необходимые паттерны проектирования, разработка игрового интерфейса с помощью MVx паттернов, изучим идею разделения данных и логики при разработке геймплея и много другое.
При проектировании программы учитывался тот факт, что голое изучение теории может быстро утомить, поэтому блоки грамотно совмещают
теоретические знания и практику, т.е. почти все, что мы будем изучать, выльется в те или иные игровые механики/практические задачи/проекты.



Тебе подойдет курс, если ты

• Разрабатываешь казульные игры, но хочешь попробовать себя на проектах посложнее
• Чувствуешь нехватку способностей, чтобы довести проект от начала до релиза
• Обожаешь делать игры и хочешь развиваться в этом направлении с единомышленниками
• Начал разрабатывать игры, но чувствуешь нехватку знаний по языку или неуверенность в работе с движком

Чему вы научитесь на курсе:

• Язык C#
  Начнем изучение с основ и закончим продвинутым уровнем. События, интерфейсы, лямбда выражения и многие другие особенности языка станут вашими помощниками в написании чистого и понятного кода
• Делать 2D и 3D механики
  В ходе курса мы будем создавать множество игровых механик, а также изучать инструменты движка, которые помогут в работе как над 3D, так и над 2D проектами
• Визуал
  Игры – не только программирование. Мы разберем множество аспектов, которые помогут украсить вашу игру. Анимации, настройка света, ассетов и материалов, создание эффектов – это и многое другое мы освоим в ходе курса
• Создавать игры
  Да, многие школы любят называть механики играми. Однако создание завершенного продукта требует гораздо больших усилий, чем просто сделать игровую часть. Поэтому в курсе предусмотрен отдельный блок, где мы с накопленными знаниями создадим завершенный проект с нуля
• Физика
  Почти в любой игре присутствуют элементы физики: гравитация, расчет столкновений, рейкасты и многое другое. Поэтому не мало времени на курсе уделяется изучению физических особенностей движка и применению их на практике
• Математика
  Для создания игр просто необходимы базовые знания в области математики и геометрии. Поэтому на курсе выделены отдельные блоки, где мы на примере реализации игровых ситуаций окунемся в эту тему

Программа курса

0-й блок. Знакомство. Подробнее о курсе
Отведём немного времени на знакомство и обсудим, что нас ждет на курсе.

Модуль 1. C# базовый
Набираем необходимый минимум по языку на примере создания консольных приложения с использованием платформы .NET, чтобы войти в Unity уже немного подготовленными и не растеряться при создании первых игровых механик.

Спойлер: Подробно:

1-й блок. С# для начинающих.
Набираем необходимый минимум по языку, чтобы войти в Unity уже немного подготовленными и
не растеряться.

Неделя 1.

• Зачем этот блок и почему не прыгнуть сразу в Unity?
• Типы данных, работа с ними, операции, преобразования, особенности работы со строками.
• Первое консольное приложение
• Условные операторы (if else, switch) и рекомендации по работе с ними
• Циклы for, foreach, while - в каких случаях и какой лучше использовать?

Неделя 2.

• Массивы и списки (Arrays и Lists). Особенности и различия
• Чем отличаются ссылочные типы (reference types) от типов значений (value types). Какие
• опасности вас могут ждать.
• Методы. Перегрузка методов.
• Коллекции (вспоминаем списки и изучаем словарь (Diction)ry), очередь (Queue), стэк
• (Stack)). Когда их удобно использовать?

Неделя 3.

• Классы и экземпляры классов. Конструктор и деструктор объекта (базовое понимание)
• Поля, переменные, свойства. В чем принципиальная разница?
• Модификаторы доступа и их необходимость

Модуль 2. Знакомство с Unity
Знакомимся с Unity, интерфейсом. Осваиваем базовые инструменты и отрабатываем полученные в прошлом блоке знания уже на механиках в движке. Также не забываем, что разработка игры – не только код, поэтому этот блок также посвящен изучению инструментов анимации и эффектов на базовом уровне, работе с материалами, импорту и настройке ассетов различными способами.

Спойлер: Подробно:

2-й блок. Знакомство с Unity.
Знакомимся с Unity, интерфейсом. Осваиваем базовые инструменты и отрабатываем полученные
в прошлом блоке знания уже на механиках в движке. Также не забываем, что разработка игры -
не только код, поэтому этот блок также посвящен изучению инструментов анимации и эффектов
на базовом уровне, работе с материалами, импорту и настройке ассетов различными способами.

Неделя 4.

• Знакомство с Unity. Создание первого проекта, какие предустановки проектов бывают, их
• различия. Интерфейс программы
• Базовые инструменты для работы. Создание объектов на сцене и взаимодействие с ними
• Базовые настройки сцены и камеры. Разные виды проекций
• Некоторые шорткаты и лайфхаки для упрощения работы
• Создание скриптов. Почему кажется, что С# в Unity другой, но на самом деле это не так,
• как применить полученные знания языка в игре?
• Разбираем основной цикл работы Unity.
• Отработка пройденных тем на создании первых механик в движке

Неделя 5.

• Работа с материалами, текстурами, пакетным менеджером. Делаем наш пример более
• симпатичным и реализуем еще одну механику
• База по анимациям и эффектам
• Небольшое заключение по начальному этапу. Подводим результаты

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

Спойлер: Подробно:

3-й блок. Необходимая математика для создания игр + технические моменты
Как бы не хотелось этого избежать, но базовые знания математики и смежных областей
необходимы для создания даже самых простых игр. Поэтому данный блок посвящен
обязательным темам для комфортного создания игр. Разберем теорию и научимся применять все
это в Unity. Кроме того, научимся работать с GIT и отладкой проекта

Неделя 6.

• Работа с векторами. Векторная математика
• Математические теоремы, которые часто пригождаются для расчетов
• Кватернионы, углы Эйлера
• Перевод между разными системами координат

Неделя 7.

• Система контроля версий. Как пользоваться удаленным репозиторием и какие
• инструменты в этом помогут?
• Как дебажить проект и находить ошибки? Какие инструменты для этого можно
• использовать.
• Базовая работа с физикой в Unity
• Отличия Update и FixedUpdate, где и какую логику надо писать
• Rigidbody и способы работы с ним
• Коллайдеры и взаимодействия между объектами

Модуль 4. C# средний уровень + углубление в Unity.
Углубляемся в язык, чтобы реализовывать более сложные механики и системы. Кроме того, этот и последующие блоки, в отличие от первого, предусматривают плотную интеграцию с движком, т.е. знания языка будут сразу переплетаться с работой в Unity, созданием игровых механик и сопутствующими нюансами для лучшего усвоения материала, без обращения к консольным приложениям. Наследование, полиморфизм, подробное рассмотрение компонентной системы, особенности Monobehaviour и многое другое нам предстоит изучить в данном блоке

Спойлер: Подробно:

4-й блок. С# средний уровень + углубление в Unity.
Углубляемся в язык, чтобы реализовывать более сложные механики и системы. Кроме того, этот и
последующие блоки, в отличие от первого, предусматривают плотную интеграцию с движком, т.е.
знания языка будут сразу переплетаться с работой в Unity, costанием игровых механик и
сопутствующими нюансами для лучшего усвоения материала.

Неделя 8.

• Введение в ООП - что такое и с чем едят.
• Наследование - в чем прелесть и чем опасно?
• Что такое Monobehaviour в Unity? Почему наследуемые от Monobehaviour классы лишены
• конструкторов и другие особенности
• Система префабов в Unity. Original и variant prefab.
• Что такое Instantiate? Правильное создание и инициализация объектов на сцене.
• Абстрактные классы
• Виртуальные и абстрактные методы - подводные камни
• Полиморфизм - лучшее, что придумало человечество

Неделя 10.

• База по UI элементам. Как делают хп бары, магазины и тд?
• Код стайл - что это такое и как это помогает в разработке проекта.
• Лайфхаки для лучшей читаемости кода
• Try методы - как организовать работу с методом, который может не выполниться?
• Принципы DRY, KISS, YAGNI - разбираем на пальцах

Модуль 5. Изучение важных инструментов в Unity
В предыдущих блоках мы уже научились работать с Unity, реализовали несколько механик и изучили довольно много вещей, связанных с языком программирования, однако в движке есть дополнительные важные инструменты, которые необходимо освоить и научиться использовать. В этом блоке будут разобраны многие инструменты и пакеты, которые используются для реализации как 3d, так и 2d механик

Спойлер: Подробно:

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

Неделя 11.

• Углубляемся в физику и математику.
• Рейкасты, физические слои.
• Математические функции, интерполяция и работа с графиками.
• Скалярное и векторное произведения. Как применять для игровых механик
• Физическое и нефизическое движение. Как реализуется и какой вариант лучше?
• Инструмент Cinemachine. Учимся продвинутой работе с камерой

Неделя 12.

• Продвинутая работа с анимациями в Unity. Mecanim animation system. Учимся импортировать уже готовые анимации, переиспользовать существующие и работать со слоями
• Анимационные события. Как реагировать на определенные моменты анимации?
• Что именно является ИИ? Базовое разделение логики принятия решений и управляемого объекта
• Паттерн фасад. Как заставить несколько систем удобно работать вместе?
• NavMesh. Поиск пути на уровне
• Препятствия и генерация сетки для навигации ИИ
• Как заставить ИИ прыгать?

Неделя 13.

• Понятие асинхронного программирования. Корутины
• Правильный менеджмент корутин и особенности их выполнения
• Инструменты работы со звуком в Unity
• Shader graph. Введение в создание шейдеров

Неделя 14.

• Работа со спрайтами. 2D анимации
• Tilemap - как быстро и удобно создавать 2д миры
• Отличается ли физика в 2D?
• Особенности разработки в 2D по сравнению с 3D

Модуль 6. Дополнительные темы
В этом блоке будет разобрано несколько важных тем, не относящихся напрямую к разработке игры в движке. Тем не менее это важные составляющие при разработке любого проекта: принципы разработки, которых стоит придерживаться, система контроля версий, код стайл, способы отладки проекта - все это используется при создании любой игры

Спойлер: Подробно:

6-й блок. С# и Unity - Продвинутый уровень
Изучаем продвинутые техники программирования. В этом блоке разобраны обязательные вещи,
которые необходимы при создании любого проекта, благодаря ним архитектура игры получается
более удобной и гибкой. Каждый junior программист обязан знать данные темы и уметь
применять их на практике.

Неделя 15.

• Делегаты. Создание коллбэков по завершении действий
• Анонимные методы и лямбда выражения
• События - сделай свой код менее связным
• Рефакторинг предыдущих проектов с учетом новых знаний
• Как на событиях реализовать простую реактивность (реактивные свойства и списки)

Неделя 16.

• Generics (обобщения) - переиспользование кода и избавление от дубляжа
• Как реализовать универсальное хранилище
• Что такое сериализация в Unity? Как отображать# классы в инспекторе?
• Кастинг классов. Изучение is, as конструкций
• Boxing/unboxing. Особенности использования структур и интерфейсов
• LINO - удобная работа с коллекциями. Опасно ли использование для производительности?
• Исключения (exception) - какие бывают и зачем нужны?
• Инкапсуляция. Как соблюдать? Опасности наследования и protected членов
• Интерфейсы IEnumerable, IReadOnlyList, IReadOnlyDictionary
• IDisposable - зачем нужен этот интерфейс и как его применять
• Тип object - самый главный родственник для всех типов в C#
• Атрибуты в Unity. Обязательные атрибуты для разработки проекта.
• OnValidate - валидация данных

Неделя 17.

• Подготовка к финальному проекту
• Рефакторим одну из предыдущих механик с ботами, доводя ее до цельной игры с правилами и четким порядком выполнения
• Разбираемся на примере данной мини игры с понятиями конфигов, игровых ресурсов
• Знакомимся с паттерном фабрики, применяем его для лучшей организации создания игровых объектов
• Менеджмент сцен. Как правильно загружать сцены
• Как без проблем менять окружение в вашей игре. Аддитивные сцены
• Делаем заключение по проблемам, которые начинают возникать в ходе разработки
• целостной игры, чтобы начать их решать при организации большой игры с нуля

Модуль 7. C# и Unity - Продвинутый уровень
Изучаем продвинутые техники программирования. В этом блоке разобраны обязательные вещи, которые необходимы при создании любого проекта, благодаря ним архитектура игры получается более удобной и гибкой. Каждый junior программист обязан знать данные темы и уметь применять их на практике.

Спойлер: Подробно:

7-й блок. Создание полноценного проекта
К этому моменту у нас за плечами уже множество реализованных механик, мы знакомы с основными инструментам Unity, хорошо владеем С#.
Теперь мы готовы к созданию полноценного проекта.
В ходе этого блока будет реализована полноценная игра, по максимуму задействуем полученные знания, изучим дополнительные необходимые
инструменты для разработки, обсудим, как можно организовать разработку с нуля и многое другое.
Игра будет состоять из полноценного главного меню с дополнительными мета механиками + будет реализована интересная геймплейная часть

Неделя 18

• Создание проекта, с чего в первую очередь можно начать?
• Разбираем возможные структуры организации папок и сцен
• Организация порядка выполнения всего проекта. Создание точки входа в приложение подконтрольный старт каждой сцены
• Знакомство с понятием сервисов. Как строить модульную архитектуру на основе отдельных сервисов для решения задач
• Реализуем первые сервисы (загрузка конфигов, ресурсов, асинхронность и тд)
• Реализуем систему конфигурации проекта. Как удобно и централизировано настраивать
  игру через настроечные файлы с потенциальной возможностью поддерживать загрузку конфигов из облака
• Как управлять жизненным циклом сервисов?
• Рассмотрение возможных механизмов внедрения зависимостей по проекту: синглтон, сервис локатор, DIContainer.
• Как итог - реализация своего DI контейнера, на котором рассмотрим принцип работы такого подхода его преимущества
• Реализация родительских контейнеров
• Реализация сервиса смены сцен с загрузочным экраном
• В итоге получаем понятную и поддерживаемую схему работы всего проекта

Неделя 19

• Разбираемся с вопросом сохранения данных
• Какие есть варианты работы с данными по проекту. Как сделать решение, которое можно
• перетаскивать из проекта в проект?
• Решаем основные задачи сохранения:
  - Сериализация
  - Хранение (с возможностью хранить данные удаленно)
  - Ключи
• Познакомимся с самым популярным форматом для сериализации данных - json и пакетом для работы с ним
• Реализуем гибкий механизм актуализации данных со всего проекта
• Как начинать игру сначала и как сбрасывать сохранения?
• Как удобнее разбивать данные для сохранения

Неделя 20

• Начинаем организацию UI в игре
• К этому моменту мы уже знакомы с подходом, основанным на model view варианте и можем переходить к изучению более сложных концепций
• Разбираемся, что такое MVx подходы и как их можно применять в разработке игр
• Посмотрим, как с помощью MVx паттернов реализовывать UI в игре, причем как простые
• элементы интерфейса для отображения, например, валюты, так и вложенные, по типу всплывающих окон
• Организуем сервис попапов
• Разберемся с анимацией интерфейса на основе пакета DoTween. Разберем как простые варианты, так и довольно сложные очередности анимаций
• По итогу получим довольно универсальную схему для работы с UI в широком пласте проектов

Неделя 21

• Начинаем организацию геймплея
• Рассмотрим ООП подходы для организации игровых объектов, с которыми мы уже знакомы, и подробно сравним их с Data oriented решениями
• Для знакомства с Data oriented подходом реализуем игровые сущности через призму
• разделения данных и логики. Посмотрим преимущества такого хода мыслей по сравнению с классическим разбиением на объекты
• Познакомимся с идеей генерации кода и рефлексией. Очень хорошие инструменты для решения рутинных задач написания кода

Неделя 22

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

Неделя 23

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

Неделя 24

• У нас есть основная база механик. Настало время организации геймплейного цикла игры
• Добавляем основные игровые настройки
• Настраиваем отношения между игровыми персонажами, чтобы они могли распознавать союзников и врагов
• Реализуем основные этапы геймплея
• Разбираем, какие идеи могут лечь в основу организации гибкого и расширяемого цикла игры
• Выстраиваем понятную и подконтрольную схему работы геймплея

Неделя 25

• Игра - не только код и логика. До этого мы вообще не притрагивались к визуалу и анимациям, описывая все на уровне логики.
• И вот после того, как основа логической части игры готова, надо не забыть прицепить к логике визуальной отображение
• Встраиваем игровые модели
• Подключаем необходимые анимации
• Настраиваем их скорость в соответствии с логикой игры
• Добавляем UI оформление
• Делаем дополнительные игровые окна
• Встраиваем эффекты
• Обращаем внимание на то, что подключенный визуал практически не влияет на логику выполнения игры
• И как итог, превращаем проект в симпатичную полноценную игру

Неделя 26

• На этом этапе стоит обсудить вопросы оптимизации
• Нужно ли оптимизировать логику игры. Разбираемся с тем. почему не стоит этого делать заранее
• Почему чаще всего именно графическая составляющая является узким горлышком проекта?
• Запечка света
• Батчинг
• Настройки URP рендерера
• Инструменты анализа производительности проекта
• Как можно использовать пул объектов для оптимизации
• На какие настройки стоит обратить внимание при сборке билда игры
• Как работать с тенями
• На что мы, как разработчики, слабо можем повлиять при оптимизации проекта

Неделя 27

• На данном этапе у нас есть полностью готовая базовая версия игры. Но как часто бывает,
  на этом разработка не заканчивается, и появляется желание добавлять новые игровые
  фичи, поэтому просто необходимо рассмотреть, как можно добавлять новые механики в
  проект и при этом не терять модульности и гибкости при реализации
• Эти вопросы мы рассмотрим на примере реализации следующих механик
• Добавим получение способностей по ходу прохождения игры. Способности будут совершенно разные от пружинящих снарядов, до увеличения статов персонажа
• Также добавим выпадение лута с убитых врагов: монетки, опыт, здоровья и тд
• Естественно, эти механики надо иметь возможность настраивать, поэтому займемся конфигурированием этого дела
• Привяжем новый необходимый Ul и добавим новые этапы в геймплейный цикл нашей игры
• По итогу поймем, как можно добавлять новые сложные геймплейные механики, при этом
  не сильно конфликтуя с предыдущей реализаций кодовой части. Кроме того, все сильнее
  будут раскрываться преимущества организации архитектуры нашего проекта

Неделя 28

• Продолжаем внедрять новые фичи в проект
• Добавим новую мета механику с прокачкой статов персонажа между игровыми забегами
• Разберем, как можно отображать 3D модели на Ul
• Добавим новый интересно организованный попап в игру
• Посмотрим, как конфиги могут конфликтовать актуальными игровыми данными и как их подружить
• По итогу получим завершенную полноценного сложную игру с множеством как геймплейных, так и мета механик
• Вы получите навыки решения реальных игровых проблем
• Поймете, как расширять игровую систему без перелопачивания всего кора игры
• И получите множество универсальных инструкций, которых можно придерживаться при разработке собственного проекта

Модуль 8. Создание полноценного проекта
К этому моменту у нас за плечами уже множество реализованных механик, мы знакомы с основными инструментам Unity, есть крепкая база по C#. Теперь мы готовы к созданию полноценного проекта. В ходе этого блока будет реализована полноценная игра, по максимуму задействуем полученные знания, изучим способы внедрения зависимостей и напишем свой DI контейнер, научимся работать с UI с помощью MVx паттернов, соберем понятный цикл работы всей игры, обсудим как можно организовать разработку с нуля и многое другое. Игра будет состоять из полноценного главного меню с дополнительными мета механиками, а также будет реализована интересная геймплейная часть.
Подводим итоги курса. Обсуждаем полученные навыки и определяем возможные векторы
развития в области разработки игр.

Спойлер: Подробное содержание

1. Знакомство с языком

• Зачем нужен этот модуль?
• Создаем первое консольное приложение
• Что делать, если нет .NET 5.0?
• Переменные и типы
• Базовые типы данных
• Приведение типов
• Бинарные операции
• Унарные операции (инкремент/декремент)
• Строковый тип данных
• Конкатенация (сложение) строк
• Интерполяция строк
• Специальные символы
• Работа с консолью
• Парсинг ввода пользователя
• ДЗ Модуль 1

2. Условия и циклы

• Тип bool
• Условные выражения
• Логические операции
• Условные операторы
• Особенности сравнения
• Тернарная операция
• Обработка некорректного ввода
• Оператор switch
• Циклы. Цикл While
• Операторы break и continue
• Цикл Do While
• Цикл For
• Когда использовать For, а когда While?
• Практика 1
• Рекомендации по чистоте кода
• Практика 1 апгрейд
• Практика 2

3. Массивы

• Массивы
• Немного про рандом
• Нюансы массивов
• Ссылочные типы и типы значений
• Ссылочные типы на практике
• Двумерные массивы
• Вложенные циклы
• Массив массивов
• Изменение размера массива
• Строка как массив
• ДЗ модуль 2-3

4. Методы и коллекции

• Методы
• Практика по методам
• Методы void
• Зачем нужны методы
• Параметры по умолчанию
• Параметры методов и ссылочные типы
• Перегрузка методов
• Коллекции
• List
• Особенности работы List
• Очередь
• Пример использования очереди
• Словарь
• Стек

5. Классы

• Что такое классы
• Создание класса
• Классы и терминология
• Из чего должен состоять класс
• Поля и модификаторы доступа
• Применяем модификаторы доступа к полям
• Методы и классы
• Значения полей по умолчанию
• Работа с полями внутри класса
• Класс как ссылочный тип
• Конструктор и this
• Перегрузка и цепочка конструкторов
• Защита данных
• Свойства
• Автосвойства
• Сокращенная запись свойств и методов
• Итоги модуля и код стайл
• ДЗ Модуль 4-5

6. Знакомство с Unity

• О чем этот модуль
• Создаем первый проект
• Знакомство с интерфейсом
• Делаем удобную раскладку окон
• Навигация на сцене. Перемещение
• Навигация на сцене. Взаимодействие с объектами
• Окно Game подробнее
• Окно Inspector. Система компонентов
• Компонент Transform
• Компонент Camera
• Настройка playmode

7. Первые механики

• Введение в компонентую систему Unity
• Первый скрипт и выбор редактора
• Разбираем шаблон скрипта по умолчанию
• Основной цикл работы Unity
• Основной цикл работы практика
• Начинаем создание первой механики
• Получения ссылки на компонент через инспектор
• Обработка ввода для прыжка
• Vector3 и прыжок
• Получение ссылки через GetComponent
• GetComponent – возможные проблемы
• Делаем правила игры
• Улучшаем игру и код
• Добавляем подсчет очков и визуализацию границ
• ДЗ Модуль 6-7

8. Работа с визуалом

• Введение в работу с материалами и ассетами
• Из чего состоят наши 3д объекты
• Текстуры в материалах
• Импорт ассетов через стор
• Настройки FBX моделей
• Импорт сторонних ресурсов
• Родительские и дочерние объекты
• Фиксим пивот призрака
• Делаем визуал для границ
• Настройка камеры
• Настройка материала призрака
• Делаем анимацию с помощью кода

9. Анимации и эффекты

• Введение
• Начало разговора про анимации
• Компонент Animator
• Animator Controller
• Окно Animation
• Создаем первую анимацию
• Добавляем еще две анимации
• Параметры и условия переходов
• Настройка переходов
• Переключение анимаций из скрипта
• Анимации. Нюансы
• Эффекты база
• Trail
• Делаем эффекты для призрака
• Заставляем эффекты работать из кода
• Делаем более живое окружение
• Анимируем призрака
• Итоги игры с призраком
• ДЗ Модуль 8-9

10. Математика в Unity

• Введение
• Базовые операции
• Немного про иксы и игрики
• Базовые теоремы
• Введение в векторную математику
• Система координат и вектор
• Отоносительность вектора
• Находим длину вектора
• Умножение на число
• Сложение векторов
• Вычитание векторов
• Дополнительные свойства векторов
• Единичный вектор
• Трехмерная система координат
• Практика 1. Подготовка сцены
• Практика 2. Отслеживание расстояния
• Практика 3. Разбор на картинке
• Практика 4. Патрулирование по точкам
• Практика 5. Агр врага

11. Системы координат и повороты

• Системы координат - введение
• Системы координат. Unity
• Локальные системы координат в коде
• Vector3 и оси
• Преобразование координат
• Какие еще бывают системы координат в юнити
• Введение в повороты
• Разбираемся с типом Quaternion
• Как работать с Rotation в коде
• Новые методы для вращения
• Операции с Quaternion
• Повороты. Практика
• Повороты. Практика 2
• Повороты. Практика 3
• ДЗ Модуль 10-11

12. GIT и дебаг игры

• Что такое система контроля версий
• Подготовка к использованию GIT
• Создаем локальный репозиторий
• Коммиты
• Удаленный репозиторий и readme файл
• Клонирование репозитория
• Ветки и merge изменений
• Конфликты при слиянии веток
• Небольшие дополнения
• Дебаг игры

13. Введение в физику игры

• Введение в физику Unity
• Коллайдеры
• Rigidbody
• Update или FixedUpdate
• Режимы приложения силы
• Практика 1 Подготовка сцены
• Практика 2 Пишем логику движения ракеты
• Практика 3 OnTrigger методы
• Практика 4 OnCollision методы
• Практика 5 Заканчиваем мини игру с ракетой
• ДЗ Модуль 12-13

14. Введение в ООП

• Введение в ООП
• Принципы ООП. Абстракция
• Принципы ООП. Инкапсуляция
• Принципы ООП. Полиморфизм
• Принципы ООП. Наследование
• Наследование практика
• Особенности наследования
• Protected поля
• Наследование от Monobehaviour
• Система префабов в Unity
• Префаб варианты
• Создание объектов на сцене. Метод Instantiate
• Пример со спавном монет
• Улучшаем пример с монетками

15. Абстрактные и виртуальные члены класса

• Введение
• Виртуальные члены класса
• Абстрактные классы и члены класса
• Введение в полиморфизм
• Рассматриваем полимфоризм на примере
• Абстракции и полиморфизм
• Прокачиваем пример с монетками
• Подводные камни виртуальных методов
• ДЗ Модуль 14-15

16. Интерфейсы и композиция

• Интерфейсы введение
• Отличия интерфейсов и абстрактных классов
• Пример использования интерфейсов
• Интерфейс или абстрактный класс-
• Паттерн стратегия. Теория
• Стратегия. Практика
• Композиция или наследование
• Проблемы наследования
• Композиция

17. Дополнительные инструменты языка

• Структуры введение
• Структуры конструкторы
• Тонкости работы со структурами
• Неизменяемость структур
• Особенности сравнение с помощью Equals
• Отсутствие наследования и заключение
• Статика введение
• Статические методы
• Статический конструктор
• Почему статика - плохо
• Константы и readonly поля
• Readonly
• Enum. Перечисления
• Enum особенности
• Модификатор ref
• Модификатор out
• Namespace и using
• ДЗ Модуль 16-17

18. База UI в Unity

• Введение в UI. Canvas
• Canvas scaler и graphic raycaster
• RectTransform
• Дополнительные особенности работы с UI
• Image
• Работа с UI из кода
• Текст и Text Mesh Pro
• Button
• Slider
• LayoutGroups
• Mask
• Scroll view
• Улучшаем игру с призраком 1
• Улучшаем игру с призраком 2
• Улучшаем игру с ракетой

19. Код стайл и принципы программирования

• Код стайл
• Базовые принципы программирования
• DRY
• KISS
• YAGNI

20. Продвинутая физика и математика

• Рейкасты введение
• Знакомство с рейкастами
• DrawGizmos
• Дополнительные варианты виртуального каста
• Пример с нанесением урона. Подготовка
• Пример с нанесение урона. Реализация
• Пример с нанесением урона. Улучшение
• Анализ получившегося решения
• Физические слои. Матрица коллизий
• Слои и код теория
• Пример с рейкастами
• Дополнительные примеры
• Как работать с графиками
• Синус и косинус
• Lerp. Интерполяция
• Скалярное произведение
• Делаем область видимостти врага
• Расширяем систему
• Векторное произведение
• Стабилизируем ракету

21. Варианты движения и работа с камерой в Unity

• Варианты движения персонажа
• Обзор сцены
• Физический вариант. Реализация
• Физический вариант. Результат
• Кинематический вариант. Реализация
• Кинематический вариант. Результаты
• Character Controller вариант. Реализация
• Character Controller вариант. Результат
• Про кастомный вариант движения
• Итоги по вариантам движения
• Cinemachine введение
• Параметры CinemachineBrain
• Основные параметры виртуальной камеры
• TopDown камера
• 3dPersonFollow вариант
• Орбитальная камера
• TargetGroup камера
• 3dPerson свободный вариант
• Итоги по пакету
• Пример с машинкой введение
• Пишем логику движения
• Дорабатываем логику движения
• Добавляем визуал и говорим про новую концепцию разработки
• Еще несколько украшательств
• Добавляем вращение частей машинки
• Результат и добавление новой камеры
• Финал
• ДЗ Модуль 20-21

22. Продвинутые анимации

• Введение
• Гуманоидная система анимаций
• Подготовка
• Где брать анимации
• Ретаргетинг анимаций
• Окно animations
• Дополнительная практика
• Анимационные слои
• Маски в анимационных слоях
• Деревья смешивания
• Типы смешивания
• Анимационные события введение
• Анимационные события реализация
• Пара слов про анимационные ключи

23. Навигация в игре

• Введение
• Подготовка к примеру
• Пишем код передвижения
• Добавляем анимации и камеру
• Анализируем решение
• Паттерн фасад
• Доделываем контроллер
• Зачем мы вынесли управление
• Попрактикуемся еще немного
• Небольшое заключение
• Зачем это все
• NavMesh введение
• NavMesh сетка
• Решаем проблему лишних сгенерированных областей
• Подготовим врага
• Пользуемся сеткой из кода
• Подготовка к созданию контроллера врага
• Создание контроллера врага
• Создаем первого агента
• Физика и NavMeshAgent
• Настройки NavMeshAgent
• Переделываем логику агра на вариант с агентом
• Navmesh link
• Obstacles
• Запекание сетки во время игры
• Выводы по пакету
• ДЗ Модуль 22-23

24. Асинхронность и корутины

• Введение
• Постановка проблемы
• База корутин. IEnumerator
• База корутин. Автоматический перебор
• В чем же асинхронность
• Особенность выполнения корутин
• Менеджмент корутин
• Рекомендация по остановке корутин
• Ожидание другого IEnumerator
• Ожидание корутин
• Практика с корутинами 1
• Фиксим проблемки
• Пишем новый вариант движения
• Фиксим дрожание камеры
• Фиксим дрожание при повороте
• Доработаем зоны для агентов
• Практика с корутинами 2
• Как запустить корутину в немонобех классе
• Заканчиваем логику работы прыжка
• Дорабатываем вертикальное отклонение
• Добавляем анимацию прыжка

25. Звуки и шейдер граф

• Звуки в Unity
• Компонент audioSource
• Как воспроизводить звуки
• Параметр Pitch
• PlayOneShot
• Разбор audioMixer
• Создаем новые группы
• Как работать с миксером через код
• Эффекты
• Итоги по звуку
• Введение в шейдеры
• Что такое шейдеры
• Что такое шейдер граф
• Создание шейдеров
• Разговор про цвета
• Обзор интерфейса
• Master стек
• Про переменные
• Вершинный шейдер
• Результат синуса
• Про пространства
• Добавим время
• Шейдер градиента
• Шейдер растворения
• Подстраиваем шейдер растворения под наш случай
• Фиксим глаза
• Добавляем функционал спавна
• Отображение спавна
• Подсветка границы
• Финал по шейдерам
• ДЗ Модуль 24-25

26. Разработка в 2D

• Введение в 2D
• Импорт графических ассетов
• Спрайты
• Компонент SpriteRenderer
• Настройка спрайта
• 2D анимации
• Сортировка спрайтов на сцене
• Сортировка вдоль оси
• Sorting group
• Tilemaps
• Создаем Tile pallete
• Рисуем на тайлмапе
• Tile Rule
• Варианты tile rules
• Тайлмапы и коллайдеры
• Несколько тайлмапов
• Особенности работы в 2D
• Начинаем делать персонажа
• Добавляем определение земли
• Гравитация и прыжок
• Добавляем анимации
• Подключаем view
• Добавляем камеру с ограничением области
• Фиксим возможное залипание на стенах
• Фиксим залипание на потолке
• Фиксим плохую обработку коллизий
• Добавляем платформы
• Заключение
• ДЗ Модуль 26 (опциональное)

27. Делегаты

• Введение
• Что такое делегаты
• Знакомимся с делегатами
• Подписки и отписки на делегаты
• Особенности подписок
• Правильный вызов делегата
• Invocationlist
• Зачем это все нужно
• Введение в практический пример
• Делаем получение предмета с фильтрацией
• Пользуемся фильтрацией
• Анонимные методы
• Лямбда выражения
• Делегаты Action и Func
• Небольшой итог по практическому примеру
• Делегат как callback
• Делегат как callback. Реализация
• WaitUntil и WaitWhile
• Промежуточный итог по делегатам

28. События

• Событие введение
• Знакомимся с событиями
• Технические отличия делегатов и событий
• Более практические отличия
• Передача параметров в событии
• Использование Action
• Код стайл в отношении событий
• Важно. Подписки и отписки
• Важно. Лямбды и подписки
• Практика введение
• Разгружаем визуал птички
• Выносим изменение скейла
• Универсализируем работу с Bird
• Выносим логику прыжка
• Выносим отображение смерти
• Выносим подсчет очков
• Делаем отображение очков
• Логика отслеживания смерти
• Заканчиваем рефакторинг
• Выводы
• ДЗ Модуль 27-28

29. Generics и инкапсуляция

• Generics введение
• Generics подготовка примера
• Generics реализация
• Использование нескольких универсальных параметров
• Ограничения обобщений
• Какие еще могут быть ограничения
• Сериализация Generics
• Дополнительные вещи
• Простая реактивность с использованием Generics
• Простая реактивность. Подготовка
• Проблемы текущего подхода
• Пишем простой вариант реактивности
• Добавляем обобщение
• Меняем health на реактивность
• Используем реактивность снаружи
• Можно самим развивать эту идею
• Инкапсуляция. Введение
• Модификаторы доступа
• Конструкторы
• Ограничение типом
• Валидация входящих данных и ошибки
• Как работать с данными. Методы
• Зажевывание ошибок
• Методы проверки и Try методы
• События и свойства
• Получение коллекций
• ReadOnly интерфейсы. Выдача ссылочных типов на чтение
• IEnumerable
• Свои ReadOnly интерфейсы
• Защита типом на уровне логики
• Неявный доступ к ссылочным типам
• Заключение

30. Финальные штрихи

• Введение
• Интерфейс IDisposable
• Кастинг типов введение
• Принцип работы. Апкастинг
• Принцип работы. Даункастинг
• В чем опасность даункаста
• Как работать с даункастом
• Перебор типов с использованием Switch
• Касты. Практика. Подготовка
• Касты. Практика. Добавляем здание
• Касты. Практика. Используем кастинг
• Тип object. Метод ToString
• Тип object. Метод GetType
• Тип object. Проблемы сравнения с помощью Equals
• Боксинг и анбоксинг
• Проблема структур и интерфейсов
• Чем же IEquatable лучше object.Equals
• Универсальный список и generics методы
• LINQ. Введение
• Select
• Where
• Совмещение разных методов
• Сортировка
• Первый или последний элемент
• Макс или мин значение
• Группировка по признаку
• Когда опасно использовать Linq
• Сериализация в Unity. Введение
• Какие требования есть к сериализуемым полям
• Сериализация. Практика
• Сериализация пользовательских типов
• Лайфхак с отображением словаря
• Атрибуты для защиты
• Кастомная валидация
• Исключения
• Демонстрация исключений
• Какие стандартные типы ошибок бывают
• Обработка исключений
• Несколько блоков catch
• Свои типы ошибок
• Заключение по исключениям
• ДЗ Модуль 29-30

31. Подготовка к финальному проекту

• Введение
• Подчищаем лишнее
• Делаем спавнеры. Спавн героя
• Делаем спавнеры. Спавн врагов
• Проблема порядка инициализации
• Возможные сомнительные решения
• Точка входа (bootstrap)
• Делаем экран загрузки
• Добавляем окно подтверждения начала игры
• Контроль должен быть не только на старте игры
• Добьем вьюху
• Выносим апдейт контроллеров
• Паттерн фабрика
• Делаем фабрику контроллеров
• Делаем фабрику персонажей
• Как сильно надо разбивать фабрики
• Заключение по фабрике
• Scriptable Objects. Настройки игры
• Конфиг для героя
• Конфиг для врага
• Особенности работы со ScriptableObject
• Убираем monobehaviour у спавнеров
• Папка Resources
• Можно подгружать не только конфиги
• Особенности работы с папкой Resources
• Добавляем игровые правила. Конфиги
• Описываем игровой режим
• Обрабатываем уничтожение объектов
• Геймплейный цикл
• Загрузка сцен
• Аддитивная загрузка сцен
• Заключение
• ДЗ Модуль 31

L_1 Начинаем организацию проекта

• Введение
• О чем будет финальный блок
• Подготавливаем проект
• Организация папки Assets в проекте
• Куда двигаемся дальше
• Вводим понятие сервиса для решения проблем проекта
• Создаем сервис запуска корутин-
• Создаем сервис загрузки ресурсов-
• Создаем сервис конфигов
• Откуда брать конфиги
• Проверяем сервис конфигов
• Использование Namespace и работа через IDE
• Проблема внедрения зависимостей
• Сомнительное решение. Singleton
• Среднее решение. ServiceLocator
• Почему сервис локатор - среднее решение
• Хорошее решение. DIContainer
• Первая версия DIContainer. Регистрации
• Первая версия DIContainer. Добиваем контейнер
• Используем контейнер
• Разбираем особенности работы контейнера
• Несколько важных моментов
• Решаем проблему циклических зависимостей
• Точка входа для всего проекта
• Реализация точки входа
• Точка входа. Инициализация проекта
• Сервис подгрузки сцен
• На какие сцены разбивать проект
• Внедряем загрузочный экран
• Организуем переход между сценами
• Организуем точки входа и передачу контейнера
• Передача доп параметров на сцену
• Контейнер сцены и контексты программы
• Реализуем систему родительских контейнеров
• Поддержка глобального контейнера и контейнера сцены
• Промежуточное заключение по общему циклу работы проекта
• ДЗ Модуль L_1

L_2 Сохранение данных

• Введение
• С чего начнем
• Прокачиваем реактивность
• Добавляем возможность отписаться
• Зачем это нужно
• Фиксим неприятную проблему
• Добавляем валюты
• Создаем сервис кошелька
• Регистрируем и проверяем кошелек
• Из чего состоит задача сохранения данных
• Какие этапы надо реализовать для сохранения готовых данных
• Сериализация и десериализация
• В какой формат сериализовать
• Пакет для сериализации NewtonsoftJson
• Реализация json сериализатора
• Проверяем работу сериализатора
• Доп. настройки сериализации. Тип форматирования
• Доп. настройки сериализации. Обработка имени типа
• Ключ для сохранений
• Хранилище данных
• Реализация хранилища. Сохранение в файл
• Реализация хранилища. Сохранение в PlayerPrefs
• Cервис сохранений
• Реализация сервиса сохранений
• Регистрируем сервис
• Тестируем сервис сохранений
• Немного про реализацию на корутинах
• Актуализация данных проекта. Второй глобальный вопрос
• Создаем провайдер данных
• Задача сброса данных до дефолтного состояния
• Реализуем сброс данных на старте игры
• Откуда брать стартовое состояние данных
• Задача актуализации данных игры
• Реализуем идею актуализации данных
• Регистрируем сервис кошелька
• Особенности данной реализации
• Добавляем NonLazy регистрации
• Проверяем работу DataProvider
• Как разбивать данные
• Заключение по системе работы с данными
• ДЗ Модуль L_2

L_3 Организация UI

• Введение
• Приложение – это бизнес логика и ее отображение
• Мы неправильно делали игры
• Причем тут UI
• Какие есть подходы к разработке UI
• Про MVx подходы
• В чем суть MVP
• Отображение отдельной валюты с помощью MVP
• Делаем заготовку на сцене
• Конфиг для иконок валют
• Презентер валюты
• Фабрика для презентеров
• Важный нюанс по работе с контейнером
• Связываем готовую вью и презентер
• В чем прелесть пассивной View
• Создаем View динамически. Фабрика вьюх
• Динамический вариант создания вьюхи
• Иерархический MVP
• Делаем вьюху для кошелька
• Презентер кошелька
• Связываем все воедино
• Проблема инициализации и деинициализации сцены
• Прокачиваем контейнер
• Фиксим проблему с деинициализацией презентера кошелька
• Промежуточный итог по MVP
• Корневой канвас. Слои UI
• Как получать доступ к слоям
• Организация главного экрана
• Возвращаем отображение кошелька на главный экран
• Попапы в игре
• Как выглядит стандартная организация попапа
• Готовим базу под визуальную часть
• Прикручиваем вьюху к тестовому попапу
• Готовим базу под презентер
• Делаем презентер тестового попапа
• Сервис для попапов. Открытие тестового попапа
• Реализуем процесс закрытия
• Немножко про внешние коллбэки
• Регистрируем сервис попапов для главного меню
• Фиксим баг с отображением UI префабов
• Открываем тестовый попап
• DOTween. Анимации UI (и не только)
• Импорт DOTween
• Базовые возможности
• Методы From и SetEase
• Tween и правильное прерывание анимаций
• Очередь анимаций. Sequence
• Поддержка анимаций в дочерних классах
• Добавление коллбэков в анимацию
• Синхронизация с Presenter
• Мелкие замечания по работе дутвина
• Чего мы добились
• Внедряем сервис пройденных уровней
• Добавляем возможность сохранения
• Делаем конфиги уровней
• Делаем префаб меню уровней
• Разбираем скрипты слоя View
• Презентер для тайла уровня
• Презентер для попапа меню уровней
• Небольшой нюанс с подписками
• Тестируем попап
• Небольшой бонус
• Итоги. Универсального решения нет
• ДЗ Модуль L_3

L_4 Организация геймплейных сущностей

• Введение
• Как можно мыслить при подготовке
• Какие подходы к организации игровых сущностей мы знаем
• Data oriented подход и ECS фреймворки
• ООП ХУЖЕ ECS
• Какое решения я предлагаю выбрать в нашем проекте
• Как мы будем скрещивать ООП и ECS
• Стартовая подготовка. Запускаем EntryPoint с любой сцены -
• Стартовая подготовка. Сцена геймплея
• Стартовая подготовка. Тестовый геймплей
• Организуем компоненты
• Заводим первые компоненты
• Про реактивность в этом подходе
• Организуем Entity
• Фабрика сущностей
• Парочка красивостей
• Пользуемся фабрикой
• Начинаем организацию систем
• Реализуем первую систему
• Небольшие особенности нашей реализации
• Организуем подключение систем к Entity
• Подключаем систему движения к тестовой сущности
• Реализуем методы жизненного цикла Entity
• Реализуем обновление жизненного цикла сущностей
• Тестируем работу систем
• Проблема связи сущностей и Unity
• MonoEntity – мостик между Entity и миром Unity
• Делаем фабрику под MonoEntity
• Автоматическое уничтожение MonoEntity
• Тестируем работу с MonoEntity
• Подвязываем компоненты из Unity
• Делаем регистрацию Rigidbody
• Доделываем механику движения с использованием rigidbody
• Проверка системы и итог по MonoEntity
• Анализируем опыт использования нашего решения
• Что было бы неплохо добавить
• Решаем проблему засорения класса Entity
• Генерация кода
• Как вообще это работает
• Генерируем объявление partial class Entity
• Рефлексия
• Лайфхак по рефлексии и генерации
• Ищем необходимые типы по проекту
• Начинаем перебирать типы компонентов
• Пройдемся отладчиком
• Создаем свойство для получения компонента
• Генерируем свойство для получения поля компонента
• Фиксим имена дженериков
• Генерируем метод Add
• Метод Add без параметров
• Автоматизируем вызов генерации
• Пользуемся сгенерированным кодом
• Заключение по генерации кода
• Промежуточное заключение по организации сущностей в нашей игре
• ДЗ Модуль L_4

L_5 Первые персонажи

• Введение
• Начинаем делать призрака
• Подготовка к созданию призрака
• Добавляем механику поворота. Данные
• Добавляем механику поворота. Логика
• Конфигурируем призрака и тестим
• Фича здоровья и смерти. Данные
• Фича здоровья и смерти. Логика
• Добавляем механику смерти призраку
• Как пользоваться сервисами в системах. Делаем механику уничтожения при смерти
• Добавляем систему релиза к сущности
• Обработка смерти – продолжительный процесс
• Продолжительная обработка смерти. Данные
• Продолжительная обработка смерти. Логика таймера
• Продолжительная обработка смерти. Дорабатываем релиз
• Тестирование и новые проблемки
• Добавляем обработку смерти в другие механики
• Какие остались неприятности
• Базовая единица условий
• Комбинирование условий
• Реализуем ICompositeConditon
• Добавляем варианты логических операций
• Внедряем условия для движения и поворота
• Дорабатываем системы движения и поворота
• Дорабатываем остальные системы. Новые условия
• Внедряем новые условия в систему релиза и смерти
• Промежуточный итог по фиче смерти
• Фича получения урона
• Идея “реактивного” ивента
• Делаем сам “реактивный” ивент
• Делаем IReadOnly интерфейсы
• Фича получения урона. Компоненты
• Система получения урона
• Проверяем систему получения урона
• Добавляем коллайдеры. Механика призрака
• Реализуем сквозное движение
• Механика нанесения урона касанием
• Использовать ли NonAlloc касты
• Делаем буффер
• Отслеживание контактов. Данные
• Отслеживание контактов. Прикрепляем данные
• Система детектирования контактов
• Игнорируем себя при детектировании
• Как будем получать сущности для нанесения урона
• Решаем задачу связи коллайдеров и сущности
• Сервис регистрации коллайдеров
• Делаем регистрации коллайдеров
• Доделываем систему фильтрации сущностей
• Тестируем системы детектирования контактов
• Фича нанесения урона касанием. Данные
• Система нанесения урона касанием
• Обрабатываем выход из контакта
• Проверяем систему нанесения урона касанием
• Отключение коллайдеров при смерти. Компоненты
• Система отключения коллайдеров при смерти
• Тестируем систему
• Что умеет основной персонаж
• Готовим базу под префабы персонажей
• Готовим префаб основного героя
• Готовим метод создания основного героя
• В чем заключается суть механики атаки
• Как будем реализовывать
• Процесс атаки, заводим необходимые данные
• Система старта атаки
• Таймер процесса атаки
• Система завершения атаки
• Начинаем добавлять данные для работы процесса атаки
• Добавляем компонент для определения движения сущности
• Добиваем и проверяем процесс атаки
• Добавляем данные для задержки перед выстрелом
• Система определения окончания задержки
• Проверяем работу задержки
• Добавляем данные для реализации выстрела
• Реализуем систему выстрела
• Проверяем механику выстрела
• Механика отмены атаки. Данные
• Система отмены атаки
• Проверяем механику отмены атаки
• Механика кулдауна
• Тестируем кулдаун атаки
• Делаем префаб снаряда
• Добавляем метод создания снаряда
• Добавляем стрельбу снарядами
• Проблема стартового поворота
• Фиксим проблему стартового поворота
• Механика смерти при касании. Данные
• DeathMaskTouchDetectorSystem
• Тестируем уничтожение снарядов
• Промежуточные итоги по работе
• Можно ли расширять наше решение
• ДЗ Модуль L_5

L_6 Искусственный интеллект

• Введение
• Из чего состоит искусственный интеллект
• Объект, исполняющий указания
• Сенсоры
• Блок памяти
• Блок принятия решений
• Насколько это разбиение строгое
• Как оно устроено у нас в проекте
• На основе чего мы будем делать логику принятия решений
• Машина состояний. Теория
• В чем заключается суть работы машины состояний
• Как будет при этом меняться поведение
• Почему мы изучаем именно эту концепцию
• Объявляем IState
• Реализуем базовый State
• Делаем обертку для состояния и связей
• Реализуем переходы
• Добиваем StateNode-
• Стейт машина. Внутреннее устройство
• Как конфигурировать стейт машину
• Как будут выполняться переходы
• Анализ возможности перехода
• Начинаем делать ИИ для призрака
• Реализуем состояние покоя
• Реализуем состояние случайного движения
• Как будем генерировать новое направление
• Делаем стейт машину для AI
• Заводим фабрику для создания ИИ
• Заводим TimerService
• Настраиваем переходы между состояниями
• Фиксим отписки
• Добиваем стейт машину случайного движения
• Как будем реализовывать обработку ИИ
• Заводим абстракцию для мозгов
• Делаем реализацию мозгов на основе машины состояний
• Пишем сервис жизненного цикла для ИИ. Хранение мозгов
• Реализуем логику привязки мозгов и сущности
• Реализуем апдейт ИИ
• Подключаем все в работу
• Тестируем работу ИИ
• В чем особенность поведения главного героя
• Как будем делать управление героем. Проблема простой машины состояний
• Иерархическая машина состояний
• Реализуем возможность использовать стейт машину как состояние
• Реализуем сервис ввода пользователя
• Делаем ПК реализацию ввода
• Делаем состояние движение под управлением игрока
• Состояние атаки
• Добавляем компонент текущей цели
• Начинаем реализовывать стейт поворота к цели
• Добавляем компонента трансформа
• Доделываем стейт поворота к цели
• Собираем стейт машину с автоматическим поворотом и атакой
• Формируем мозги для нашего героя
• Тестируем получившуюся реализацию
• Идея параллельно выполняющихся состояний
• Реализуем параллельный стейт
• Делаем конкретную реализацию
• Реализуем алгоритм выбора ближайшей цели
• Добавляем генерацию Try метода для получения поля компонента
• Добиваем логику фильтрации
• Состояние поиска текущей цели
• Добиваем логику поведения героя
• Тестируем поведение. Проблема текущей реактивности
• Как улучшить реактивность. EqualityComparer
• Прокачиваем реактивность
• Тестируем финально реализацию поведения главного героя
• Итог по ИИ и машине состояний
• Стейт машина и ECS
• ДЗ Модуль L_6

L_7 Организация игрового цикла

• Введение
• В чем будет заключаться геймплей
• Конфиги для персонажей
• Конфиги для призрака и героя
• Что еще можно было вынести в настройки
• Поддержка конфигов для персонажей
• Тестируем конфиги
• Добавляем класс со слоями
• Тестируем работу и правим прицеливание
• Как размышлять дальше
• Создаем фабрику главного героя
• Создаем фабрику врагов
• Тестируем фабрики
• Что именно мы сделали
• Добавляем возможность отличать главного героя
• Отношения между персонажами
• Добавляем фичу команд
• Добавляем поддержку команд в нанесение урона
• Не боимся пользоваться статикой
• Проблема с проджектайлами
• Добавляем новый слой окружения
• Добавляем проверку касания другой команды
• Добиваем проджектайл
• Проверка проджектайлов
• Добиваем логику выбора цели с учетом команд
• Тестируем логику выбора цели
• Начинаем организацию геймплейного цикла
• Как будем организовывать волны
• Какая информация нам нужна
• Конфиг режима зачистки врагов
• Добиваем конфигурацию уровней
• Определяем то, как должны работать этапы
• Начинаем реализацию режима зачистки врагов
• Учитываем смерть врагов
• Заканчиваем реализацию режима зачистки врагов
• Заводим фабрику стейджей
• Тестируем стейдж зачистки врагов
• Сервис для контроля смены стейджей
• Добавляем функциональность
• Заводим префаб триггера
• Формируем сущность триггера
• Заводим сервис для триггера подготовки-
• Реализуем функционал
• Как собирать все вместе
• Как будет выглядеть машина состояний для геймплея
• Заводим реализацию машины состояния под геймплей
• Стейт подготовки
• Стейт обработки стейджа
• Стейты победы и поражения. База
• Стейт победы
• Стейт поражения
• Фабрика стейтов
• Стейт кор лупа
• Добавляем возможность отслеживать результат стейджа
• Добиваем стейт кор лупа
• Начинаем делать стейт машину для всего геймплея
• Сервис хранения главного героя
• Добиваем стейт машину геймплея
• Делаем GameplayStatesContext
• Собираем цикл геймплея
• Тестируем получившийся геймплей
• Фиксим сохранение при победе
• Финальный тест
• Стейт машина как способ организации игры
• Заключение
• ДЗ Модуль L_7

L_8 Визуал проекта

• Введение
• Что будем делать с графикой
• Импорт пакетов с модельками-
• Разбираем все по папкам
• Важный момент про обновление ассетов
• Добавляем модельку призрака
• Добавляем модельку героя
• Проверяем как все выглядит в игре
• Дружим отображение и данные сущностей
• Делаем WalkingView
• Оставшиеся наследники
• Добиваем анимации
• Внедряем модельку стрелы
• Внедряем модельку лука
• Подбираем тайминги для атаки
• Как синхронизировать скорость анимации с логикой
• Скрипт для изменения мультипликатора скорости анимации атаки
• Добавляем пак с эффектами
• Эффект получения урона
• Добавляем спавн для врагов
• Добавляем отображение спавна для врагов
• Добавляем отображение текущей цели для героя
• Начинаем добавлять окружение
• Добавляем окружающую арену
• Почему фиксированный размер арены
• Последний штрих – триггер активакции
• Тестируем финал по графике
• Начинаем украшать UI. Импорт спрайтов
• Выбираем иконки валют
• Дорабатываем currencyView
• Немного про шрифты
• Правим кнопку
• Добавляем фон в главное меню
• Проверяем адаптивность
• Фиксим фон
• Адаптация под челку телефона
• Фиксим адаптацию под вырезы устройств. Safe area
• Преображаем оставшиеся элементы. Меню выбора уровней
• Загрузочный экран
• Подготовка UI для геймплея
• Подготовка UI для геймплея. Новые классы
• Новые префабы и регистрации
• Попап победы. Структура префаба
• Попап победы. View часть
• Попап победы. Presenter часть
• Попап поражения. Полная аналогия
• Новая анимация для попапов
• Добавляем попапы победы и поражения в систему
• Добавляем показ попапов при поражении и победе
• Тестируем попапы
• Отображение стейджей. Префаб
• Встраиваем отображение стейджа
• Проверяем отображение стейджей
• Добавляем хп бары. Вьюхи
• Префабы хп баров
• Презентер хп бара
• Вьюха дисплея хп баров
• Добавляем новые компоненты
• HealthDisplayPresenter
• Встраиваем хп бары и тестируем
• Заключение
• ДЗ Модуль L_8

L_9 Оптимизация

• Введение
• Небольшие изменения по скрипту запуска сцены бутстрапа
• Не делай преждевременных оптимизаций
• Многие оптимизации – не ваша специализация
• Frame debugger
• Статический батчинг
• Нюансы статического батчинга
• А если объекты двигаются
• Свет и тени
• Запечка света
• Фиксим запечку света
• Фиксим свет для динамических объектов
• Quality. Пресеты графики
• Настройки URP. Отключаем SSAO
• Остальные настройки URP
• Итоги по графике
• Оптимизация UI
• Выбираем окно для тестов
• Как использовать атласы
• Думайте как упаковывать спрайты
• Оптимизации по коду
• Profiler
• Заключение

L_10 Внедряем новые фичи

• Введение
• Способности изменения статов
• Реализуем сами статы
• Добавляем системы синхронизации статов
• Эффекты для изменения статов
• Система для перерасчета статов при добавлении эффекта
• Тестируем систему эффектов
• Добавляем конфиги способностей
• Заводим базу под сами абилки
• Фабрика абилок и добавление их к персонажу
• Тестирование абилок
• Система дропа абилок
• Реализация системы дропа абилок
• Выбор абилки. Префабы
• Выбор абилки. View часть
• Выбор абилки. Presenter часть. Логика
• Добавляем опыт и уровни герою
• Подвязываем на изменение уровня выбор способностей
• Фикс отображения уровня
• Добавялем сервис паузы
• Добавляем отображение опыта и уровня
• Промежуточный итог

L_11 Финал

• Введение. Конфиги под лут
• Настройка конфигов
• База под сбор лута
• Поддержка конкретных вариантов лута
• Сервис дропа лута
• Дроп лута с врагов
• Сервис сбора лута
• Состояние сбора лута
• Отображение и начисление монет
• Прокачка статов. Конфиги
• Данные пользователя
• Правим фабрику героя
• Сервис прокачки статов
• Внедряем сервис прокачки статов
• Попап магазина прокачки. View часть
• Попап магазина прокачки. Presenter часть
• Подключаем попап в систему
• Отображение 3д модели на UI
• Прокачка способностей
• Способность мультивыстрела - конфиги
• Добавляем механику мультивыстрела
• Добавляем абилку мультивыстрела
• Способность баунса стрел - конфиг
• Добавляем логику отскока от стен
• Уменьшение счетчика отскоков
• Апгрейдим систему условий
• Добавляем саму абилку баунса
• Добавляем стат скорости атаки
• Готовим базу для изменения скорости атаки
• Система перерасчета таймингов
• Синхронизируем скорость анимации атаки
• Финальный финал

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

• Отличное владение C#
• Работа в движке Unity и изучение сопутствующих инструментов
• Реализация множества базовых игровых механик, которые обязательно пригодятся в
• любом проекте
• Полностью законченный проект (начнем с нуля и доведем ио завершённого состояния).
• наглядных примерах придет понимание того, как разрабатывать и организовывать большой проект
• Домашние задания с подробной проверкой
• По каждой теме/блоку будет краткая сводка для закрепления материала, дополнительные полезные ссылки
• Комьюнити разработчиков, с которыми вы можете пообщаться, организовать команду и обменяться опытом

Подарки для записавшихся на курс до 5 июля 2024:

1. Гайд разработчика
   Сводка каналов, материалов и книг, которые помогут вам прокачаться как разработчику (подборка сделана на основе моего опыта)
2. Сводка правил чистого кода
   Документ, где расписаны универсальные правила чистого кода для того, чтобы ваш код стал понятным и читаемым
3. СкидкПосле прохождения программы вам будет доступна пожизненная скидка 10% на прохождения моего углубленного курса по архитектуре игр

Автор: Илья Яковлев
Разработчик игр и автор обучающего YouTube канала, а так же Автор курса по архитектуре игр в Unity, на котором обучилось уже более 250 человек!

Тариф Базовый
- Доступ к закрытой группе в дискорде
- Домашние задания с полной проверкой
- Дополнительные материалы по каждому модулю
- Открытые занятия с общением каждые две недели

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