Основы разработки игр на GDevelop

Введение в GDevelop: Установка, обзор интерфейса и создание первого проекта

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

В этой первой статье мы разберем, что такое GDevelop, как его установить, изучим его интерфейс и, самое главное, создадим ваш первый интерактивный прототип всего за несколько минут.

Что такое GDevelop и почему стоит выбрать его?

GDevelop — это бесплатный конструктор игр с открытым исходным кодом (open-source). Его главная особенность — система визуальных событий. Вместо того чтобы писать код на языках вроде C# или JavaScript, вы строите логику игры, выбирая условия и действия из списка.

Представьте, что вы объясняете правила игры другу:

«Если игрок нажимает пробел, персонаж должен подпрыгнуть».

Именно так и работает GDevelop. Вы задаете условие («Нажат пробел») и привязываете к нему действие («Персонаж прыгает»).

Ключевые преимущества:

• Отсутствие необходимости в программировании: Идеально для новичков.
• Кроссплатформенность: Вы можете создавать игры для Windows, macOS, Linux, Android, iOS и веба.
• Быстрое прототипирование: Идею можно проверить за считанные минуты.
• Расширяемость: Если вы все же знаете JavaScript, вы можете писать свои расширения, но это необязательно.

Шаг 1: Установка и запуск

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

Вариант А: Работа в браузере

Вы можете запустить редактор прямо сейчас, перейдя на официальный сайт GDevelop. Нажмите кнопку Try it online. Это отличный способ быстро ознакомиться с интерфейсом, не скачивая ничего на компьютер.

Вариант Б: Установка на компьютер (Рекомендуется)

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

1. Перейдите на страницу загрузки GDevelop Download.
2. Выберите вашу операционную систему (Windows, macOS или Linux).
3. Скачайте установочный файл и запустите его.
4. После установки откройте программу. Вас встретит стартовый экран.

Шаг 2: Обзор интерфейса

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

Давайте разберем основные элементы интерфейса:

1. Менеджер проекта (Project Manager)

Обычно скрыт слева (открывается кнопкой меню). Здесь находится структура вашей игры:

• Настройки игры (разрешение, имя).
• Сцены (уровни, меню).
• Внешние события и скрипты.

2. Редактор сцены (Scene Editor)

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

3. Панель объектов (Objects Panel)

Находится справа. Здесь живут все сущности вашей игры. Важно понимать разницу:

• В панели объектов лежат «чертежи» или «шаблоны».
• Когда вы перетаскиваете объект из панели на сцену, вы создаете его экземпляр.

4. Панель свойств (Properties Panel)

Обычно находится слева или открывается при выборе объекта на сцене. Здесь можно точно настроить координаты ($X$, $Y$), угол поворота, размер и другие параметры конкретного экземпляра объекта.

5. Редактор событий (Events Sheet)

Обратите внимание на вкладки вверху рабочей области. Обычно там есть вкладка с названием вашей сцены (например, «New Scene») и рядом вкладка «New Scene (Events)». Переключившись туда, вы попадаете в «мозг» вашей игры. Здесь нет картинок, только логика в виде списка условий и действий.

Шаг 3: Основные концепции GDevelop

Прежде чем мы начнем создавать игру, нужно усвоить три кита, на которых держится GDevelop.

Объекты (Objects)

Все, что есть в игре — это объекты. Персонаж — объект. Платформа — объект. Монетка — объект. Даже текст счета на экране — это объект. У объектов есть анимации и свойства.

Поведения (Behaviors)

Это готовые наборы логики, которые можно «навесить» на объект. Вместо того чтобы программировать физику прыжка с нуля, вы просто добавляете объекту поведение «Platformer character» (Персонаж платформера). GDevelop сам обработает гравитацию, прыжки и столкновения.

События (Events)

Событие — это инструкция вида «Если... то...». Оно состоит из двух частей:

1. Условие (Condition): Когда это происходит? (Например: «Клавиша Вправо нажата»).
2. Действие (Action): Что нужно сделать? (Например: «Симулировать нажатие вправо для персонажа»).

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

Давайте создадим простейшую сцену, где персонаж сможет бегать по платформе.

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

1. На стартовом экране нажмите Build -> Create a project.
2. Выберите вкладку Empty project (Пустой проект), чтобы начать с чистого листа.
3. Укажите папку для сохранения и имя проекта.

2. Добавление сцены

1. В панели слева (если она закрыта, нажмите на иконку «гамбургер» слева вверху) найдите раздел Scenes.
2. Нажмите Add a scene.
3. Кликните по появившейся строке (обычно «New Scene»), чтобы открыть редактор.

3. Создание персонажа

1. Посмотрите на панель Objects справа. Нажмите Add a new object.
2. Выберите Sprite (Спрайт).
3. Назовите объект Player (вверху окна).
4. Нажмите Add an animation.
5. Вы можете нарисовать своего героя, нажав Create with Piskel (встроенный редактор пиксель-арта), или выбрать готового из библиотеки (Asset Store). Для начала давайте просто зальем квадрат любым цветом в Piskel и сохраним.
6. Нажмите Apply.
7. Перетащите объект Player из панели справа на сцену в центре.

4. Добавление платформы

1. Снова нажмите Add a new object -> Sprite.
2. Назовите его Platform.
3. Добавьте анимацию, нарисуйте прямоугольник другого цвета.
4. Нажмите Apply.
5. Перетащите Platform на сцену и разместите под игроком. Растяните её, чтобы она была похожа на пол.

5. Настройка поведений (Магия GDevelop)

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

Настройка Игрока:

1. Дважды кликните по объекту Player в списке объектов справа.
2. Перейдите на вкладку Behaviors (Поведения).
3. Нажмите Add a behavior to the object.
4. Найдите и выберите Platformer character (Персонаж платформера).
5. Оставьте настройки по умолчанию и нажмите Apply.

Настройка Платформы:

1. Дважды кликните по объекту Platform.
2. Вкладка Behaviors -> Add a behavior.
3. Выберите Platform (Платформа).
4. Нажмите Apply.

6. Запуск (Preview)

В верхней панели инструментов найдите кнопку Preview (значок «Play» или жучок). Нажмите её.

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

Работа с событиями

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

1. Переключитесь на вкладку New Scene (Events) (вверху, рядом с вкладкой сцены).
2. Нажмите Add a new event.
3. Условие (слева): Нажмите Add condition -> выберите объект Player -> найдите Y position -> выберите оператор $>$ (больше) -> введите значение 600 (это низ экрана по умолчанию). Нажмите OK.
   • Смысл: Мы проверяем, упал ли игрок ниже координаты 600 по вертикали.
4. Действие (справа): Нажмите Add action -> категория Scene -> Change the scene -> выберите имя вашей сцены (в кавычках, например "New Scene"). Нажмите OK.

Теперь запустите Preview. Спрыгните с платформы. Как только герой улетит вниз, уровень начнется заново.

Заключение

Поздравляю! Вы только что установили GDevelop, разобрались с интерфейсом и создали свой первый интерактивный прототип. Вы узнали, что:

• Объекты — это кирпичики игры.
• Поведения — это готовая логика (физика).
• События — это правила игры, которые вы создаете сами.

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

Работа с объектами: Спрайты, анимации, тайловые карты и построение сцены

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

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

1. Спрайты и Анимации: Оживляем героя

В GDevelop основным визуальным элементом является Спрайт (Sprite). Если говорить просто, спрайт — это 2D-изображение, которое может перемещаться по экрану. Однако в контексте разработки игр спрайт — это не просто картинка, это контейнер для анимаций.

Анатомия анимации

Анимация в 2D-играх работает по принципу мультфильмов: быстрая смена кадров создает иллюзию движения. Каждый кадр — это отдельное изображение.

Когда вы открываете редактор объекта (двойной клик по объекту), вы видите менеджер анимаций. У одного объекта может быть множество состояний:

• Idle (Покой) — персонаж просто стоит и дышит.
• Run (Бег) — цикл движения.
• Jump (Прыжок) — поза в полете.

Настройка анимации в GDevelop

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

1. Loop (Зацикливание): Если галочка стоит, анимация будет проигрываться бесконечно (идеально для бега). Если нет — проиграется один раз и остановится на последнем кадре (идеально для атаки или смерти).
2. FPS (Кадры в секунду): Скорость воспроизведения. Обычно для пиксель-арта используют значения от 8 до 12 FPS. Для плавной векторной графики — 24, 30 или 60 FPS.

Маски коллизий (Hitboxes)

Это одна из самых частых ошибок новичков. Картинка вашего героя может быть большой, но игра должна знать, где находятся его «твердые» границы.

По умолчанию GDevelop создает маску коллизии по размеру всей картинки. Но если у вашего героя есть торчащий меч или плащ, вы не хотите, чтобы он умирал, задев шипы кончиком плаща. Для этого мы редактируем маску (кнопка Edit collision masks).

«Хитбокс должен быть меньше визуального спрайта, чтобы игра казалась честной по отношению к игроку».

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

2. Тайловые спрайты (Tiled Sprites) против обычного масштабирования

Представьте, что вы строите длинный пол для уровня. У вас есть красивая текстура травы размером $64 \times 64$ пикселя.

Если вы возьмете обычный спрайт и растянете его на ширину $1000$ пикселей, картинка растянется и станет мыльной и уродливой. Здесь на помощь приходит Tiled Sprite (Тайловый спрайт).

В чем разница?

• Sprite: При изменении размера изображение растягивается (Scale).
• Tiled Sprite: При изменении размера изображение повторяется (Repeat/Tile).

Используйте Tiled Sprite для создания платформ, стен, полов и фонов. Это экономит ресурсы и выглядит аккуратно.

3. Тайловые карты (Tilemaps): Строим сложные миры

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

Тайловая карта — это сетка, где в каждой ячейке находится определенный фрагмент картинки (тайл). Это похоже на мозаику.

В GDevelop есть встроенная поддержка формата LDtk и Tiled (популярные редакторы карт), но проще всего начать с использования готовых наборов из Asset Store.

Преимущества Tilemap:

1. Производительность: Один объект Tilemap заменяет тысячи отдельных спрайтов. Компьютеру проще отрисовать одну большую сетку, чем 1000 маленьких объектов.
2. Удобство: Вы «рисуете» уровень кистью, как в графическом редакторе.

4. Построение сцены: Слои и Z-Order

Когда вы добавляете объекты на сцену, они могут перекрывать друг друга. Чтобы контролировать этот хаос, используются две концепции: Z-Order и Layers.

Z-Order (Z-индекс)

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

• Объект с $Z = 1$ лежит в самом низу.
• Объект с $Z = 10$ лежит поверх него.

Если ваш герой ($Z=5$) пробегает мимо дерева ($Z=10$), он окажется за деревом. Если дерево имеет $Z=2$, герой пробежит перед ним.

Слои (Layers)

Слои — это как прозрачные пленки, наложенные друг на друга. У каждого слоя своя камера и свои настройки. Обычно в игре создают такую структуру (снизу вверх):

1. Background Color: Цвет фона сцены.
2. Background Layer: Горы, облака (движутся медленнее для эффекта параллакса).
3. Base Layer (Основной): Здесь происходит игра (герой, враги, платформы).
4. UI / GUI Layer (Интерфейс): Жизни, счет, кнопки меню.

Важно: Объекты на слое UI никогда не перекроются объектами с Base Layer, даже если у Base Layer будет Z-Order $1000000$, а у UI — $1$. Слой, находящийся выше в списке, всегда рисуется поверх нижних слоев.

Практика: Улучшаем наш проект

Вернемся к проекту из прошлого урока. Давайте заменим цветные квадраты на графику.

Шаг 1: Замена игрока

1. Удалите объект Player (квадрат) со сцены (или просто скройте его).
2. Нажмите Add a new object -> Search Asset Store.
3. В поиске введите "Knight" или "Dino". Выберите понравившегося персонажа, у которого есть анимации Idle, Run и Jump.
4. Нажмите Add to scene.
5. Теперь у вас есть новый объект. Не забудьте добавить ему поведение Platformer character, как мы делали в прошлом уроке.

Шаг 2: Настройка анимаций

Откройте свойства нового объекта. Убедитесь, что анимации названы понятно (например, Idle, Run).

• Для анимации Run включите галочку Loop (Зациклить).
• Для Jump галочку Loop лучше снять.

Шаг 3: Создание земли через Tiled Sprite

1. Найдите в Asset Store текстуру травы (Grass).
2. При добавлении выберите тип Tiled Sprite.
3. Разместите объект на сцене и потяните за край. Видите? Трава не растягивается, а достраивается новыми блоками.
4. Добавьте этому объекту поведение Platform.

Шаг 4: Работа со слоями

1. Откройте панель слоев (кнопка справа вверху, выглядит как стопка бумаг).
2. Добавьте новый слой и назовите его UI.
3. Создайте текстовый объект Score (Счет).
4. В свойствах объекта Score (панель слева) найдите параметр Layer и выберите UI.
5. Теперь, даже если камера будет двигаться за игроком, счет будет «приклеен» к экрану.

Заключение

Теперь ваша игра выглядит намного живее! Мы научились:

• Использовать спрайты и настраивать их анимации.
• Понимать разницу между растягиванием и тайловыми спрайтами.
• Управлять порядком отображения через Z-Order и Слои.

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

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

Добро пожаловать в третью часть нашего курса по GDevelop! В предыдущих статьях мы научились создавать проект, добавлять объекты и настраивать красивые анимации. Но если вы запустите свой проект сейчас, то увидите красивую, но глупую картинку. Ваш рыцарь может бегать, но он не знает, что нужно развернуться, когда бежит влево. Он не получает урон, не собирает монеты и не переходит на новые уровни.

Сегодня мы вдохнем жизнь в вашу игру. Мы разберем Систему Событий (Event System) — мозг вашего проекта. Мы узнаем, как заставить игру «думать», принимать решения и считать цифры.

Что такое Система Событий?

Большинство игровых движков требуют написания кода на языках C#, C++ или JavaScript. GDevelop идет другим путем. Он использует визуальное программирование, основанное на логике «Причина — Следствие».

Представьте, что вы дрессируете собаку. Вы говорите: «Если я скажу 'Сидеть', то ты садишься». В GDevelop это работает точно так же:

«Если нажата клавиша 'Пробел' (Условие), то Персонаж подпрыгивает (Действие)».

Весь код вашей игры будет находиться во вкладке Events (События), которая есть у каждой сцены.

Анатомия события

Событие в GDevelop состоит из двух основных частей и одной скрытой, но важной концепции.

1. Условия (Conditions)

Это левая часть блока события. Здесь мы задаем вопрос игре: «Произошло ли это?».

Примеры условий:

• Сталкивается ли игрок с врагом?
• Нажата ли клавиша мыши?
• Здоровье меньше 0?
• Таймер истек?

Если условие истинно (True), то GDevelop переходит к правой части. Если ложно (False) — игнорирует это событие и идет к следующему.

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

2. Действия (Actions)

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

Примеры действий:

• Удалить объект (врага).
• Проиграть звук.
• Изменить анимацию.
• Переключить сцену.

3. Игровой цикл (Game Loop)

Это то, что новички часто упускают. Игра — это не статичная программа. Это бесконечный цикл, который повторяется примерно 60 раз в секунду (60 FPS).

GDevelop читает ваш список событий сверху вниз каждый кадр.

1. Проверка события №1.
2. Проверка события №2.
3. ...
4. Отрисовка картинки на экране.
5. Повторить всё заново.

Понимание этого цикла критически важно. Если вы скажете «Прибавить 1 к счету» без условий, то через 1 секунду ваш счет будет равен 60, потому что действие выполнилось 60 раз.

Выражения (Expressions): Математика внутри игры

Иногда нам нужно не просто сказать «Установи здоровье на 100», а сделать что-то сложнее: «Отними от здоровья силу удара врага». Здесь на помощь приходят Выражения.

Выражение — это формула, которая возвращает значение (число или текст). В GDevelop выражения можно вводить в поля, где требуются числа. Они часто выглядят как функции: Object.X(), MouseX(), TimeDelta().

Рассмотрим пример расчета урона. Допустим, мы хотим рассчитать остаток здоровья по формуле:

$$H_{new} = H_{current} - D$$

Где:

• $H_{new}$ — новое значение здоровья игрока.
• $H_{current}$ — текущее здоровье игрока.
• $D$ — полученный урон.

В GDevelop это будет выглядеть так: в действии «Изменить переменную Health» вы выберете оператор «Вычесть» (Subtract), а в значении напишете число урона.

Координаты и математика

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

$$d = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$$

Где:

• $d$ — расстояние между объектами.
• $x_1, y_1$ — координаты первого объекта (игрока).
• $x_2, y_2$ — координаты второго объекта (врага).
• $\sqrt{...}$ — квадратный корень.

Вам не нужно писать эту формулу вручную. В GDevelop есть готовое выражение Distance(Player, Enemy), которое сделает всю математику за вас. Но понимание того, что выражения — это просто формулы, поможет вам не бояться их.

Практика: Исправляем «Лунную походку»

Вспомните наш проект из прошлого урока. Когда мы нажимали «Влево», рыцарь двигался влево, но смотрел вправо. Это выглядит неестественно. Давайте исправим это с помощью событий.

Шаг 1: Открываем редактор событий

Перейдите на вкладку событий вашей сцены. Если там пусто, нажмите Add a new event (Добавить новое событие).

Шаг 2: Движение влево

Нам нужно сказать игре: «Когда нажата клавиша ВЛЕВО, зеркально отрази персонажа по горизонтали».

1. Нажмите Add condition (Добавить условие).
2. Найдите категорию Keyboard (Клавиатура) -> Key pressed (Клавиша нажата).
3. Выберите клавишу Left (Влево). Нажмите OK.
4. Теперь нажмите Add action (Добавить действие) напротив этого условия.
5. Выберите объект вашего Игрока.
6. Найдите действие Flip the object horizontally (Отразить объект по горизонтали).
7. Выберите Yes (Да, отразить). Нажмите OK.

Шаг 3: Движение вправо

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

1. Добавьте новое событие.
2. Условие: Key pressed -> Right.
3. Действие: Объект Игрок -> Flip the object horizontally -> No (Нет, не отражать).

Запустите Preview. Теперь ваш герой должен поворачиваться в сторону движения!

Управление анимациями через события

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

Здесь нам поможет поведение Platformer Object, которое мы добавили ранее. Оно само знает, движется персонаж или нет.

Логика переключения:

1. Событие 1:
   • Условие: Игрок Is moving (Движется). (Это условие находится внутри категории Platformer Object).
   • Действие: Игрок -> Change the animation by name -> `

Углубленные механики: Переменные, физика, поведения объектов и работа с камерой

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

В этой статье мы превратим прототип в полноценную игру. Мы разберем три кита глубокой разработки: Переменные (память игры), Камеру (глаза игрока) и Продвинутую физику (ощущение веса и инерции).

1. Переменные: Память вашей игры

Представьте, что вы играете в RPG, но игра не запоминает ваш уровень, здоровье и инвентарь. Это было бы бессмысленно. Чтобы игра могла «помнить» данные, используются переменные.

Переменная — это контейнер (коробка), у которого есть имя и содержимое. Содержимым может быть число (например, 100) или текст (например, «Игрок 1»).

В GDevelop существует три типа переменных, различающихся по «области видимости»:

Глобальные переменные (Global Variables)

Они живут во всей игре. Данные в них сохраняются при переходе между сценами (уровнями).

• Пример: Общий счет очков, настройки звука, имя игрока.

Переменные сцены (Scene Variables)

Они живут только пока активна текущая сцена. Если вы перезапустите уровень, они сбросятся.

• Пример: Количество врагов на текущем уровне, таймер до конца раунда, открыта ли дверь босса.

Переменные объекта (Object Variables)

Самый интересный тип. Эти переменные хранятся внутри конкретного экземпляра объекта. У каждого врага может быть своя переменная Health (Здоровье).

• Пример: Жизни конкретного монстра, количество патронов в конкретном оружии.

Математика переменных

Работа с переменными — это постоянная математика. Например, когда игрок получает урон, мы используем простую формулу:

$$H_{new} = H_{current} - D$$

Где $H_{new}$ — новое значение здоровья, $H_{current}$ — текущее здоровье, а $D$ — полученный урон.

В редакторе событий это выглядит как действие: Variable value -> Subtract (Вычесть).

2. Работа с камерой

По умолчанию камера в GDevelop показывает область координат $0;0$ (левый верхний угол). Если ваш уровень длинный, герой просто убежит за пределы видимости. Нам нужно научить камеру следовать за ним.

Базовое слежение

Самый простой способ — использовать действие Center the camera on an object (Центрировать камеру на объекте). Вы ставите это действие без условий (то есть оно выполняется каждый кадр), и камера жестко привязывается к игроку.

Это работает, но выглядит грубо. Каждое микро-движение игрока дергает экран, что может вызвать укачивание.

Плавная камера (Lerp)

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

Формула линейной интерполяции выглядит так:

$$P(t) = A + (B - A) \cdot t$$

Где:

• $P(t)$ — новая позиция камеры.
• $A$ — текущая позиция камеры.
• $B$ — позиция игрока (цель).
• $t$ — коэффициент сглаживания (от 0 до 1). Чем меньше число, тем плавнее и медленнее движение.

В GDevelop вам не нужно писать формулу целиком. Вы используете выражение lerp(a, b, x) в действии изменения позиции камеры:

1. Действие: Change X position of camera.
2. Значение: lerp(CameraX(), Player.X(), 0.1).

Это означает: «Каждый кадр сдвигай камеру на 10% расстояния в сторону игрока». Результат — приятное, кинематографичное слежение.

3. Продвинутая физика и силы

Мы уже использовали поведение Platformer Character, которое дает готовую физику. Но что, если мы хотим оттолкнуть врага при ударе или сделать отдачу от выстрела? Для этого мы управляем Силами (Forces).

В GDevelop есть два способа приложить силу:

Мгновенная сила (Instant Force)

Используется для резких толчков: прыжок, взрыв, удар. Сила применяется один раз и постепенно затухает (благодаря параметру Damping — сопротивление).

Постоянная сила (Permanent Force)

Действует непрерывно. Используется для конвейерных лент, ветра, гравитации или движения ракеты. Чтобы остановить объект, нужно вручную удалить эту силу.

Векторы и углы

Иногда нужно толкнуть объект не просто влево или вправо, а под углом. Здесь нам пригодятся тригонометрические функции. Например, чтобы пуля летела в сторону курсора мыши, движок вычисляет угол:

$$\alpha = \arctan(\frac{y_2 - y_1}{x_2 - x_1})$$

Где:

• $\alpha$ — искомый угол.
• $y_2, y_1$ — координаты цели и стрелка по вертикали.
• $x_2, x_1$ — координаты цели и стрелка по горизонтали.
• $\arctan$ — арктангенс, функция для вычисления угла из координат.

В GDevelop для этого есть удобное действие: Add force to move toward a position (Добавить силу для движения к позиции). Вы просто указываете MouseX() и MouseY(), и движок сам считает всю математику.

4. Поведения объектов (Behaviors): Больше, чем платформер

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

Tween (Твининг)

Это, пожалуй, самое мощное поведение для визуальной красоты. Tween позволяет плавно изменять свойства объекта (позицию, прозрачность, размер, цвет) за определенное время.

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

«Измени угол поворота двери с $0^\circ$ до $90^\circ$ за 1 секунду, используя стиль EaseOutBounce».

EaseOutBounce добавит эффект отскакивания в конце, и дверь «стукнется» об стену. Всё это — без единой картинки анимации.

Pathfinding (Поиск пути)

Идеально для врагов. Это поведение позволяет объекту находить кратчайший путь к цели, обходя препятствия (стены), которые вы пометите как Obstacles.

Physics 2.0 (Box2D)

Если вам нужна реалистичная физика (как в Angry Birds), где ящики падают, катяться и сталкиваются друг с другом, используйте поведение Physics 2.0. Оно заменяет стандартную аркадную физику на полноценную симуляцию твердых тел.

Важно: Не смешивайте Platformer Character и Physics 2.0 на одном объекте. Они конфликтуют, так как пытаются управлять движением по разным законам.

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

Давайте применим знания о переменных на практике и добавим в нашу игру монетки.

Шаг 1: Создание переменной счета

1. Нажмите правой кнопкой мыши на фон сцены -> Scene properties (Свойства сцены).
2. Нажмите Edit scene variables.
3. Добавьте новую переменную, назовите её Score. Значение по умолчанию: 0.

Шаг 2: Создание монетки

1. Создайте новый объект-спрайт Coin.
2. Разместите несколько копий на уровне.

Шаг 3: Логика сбора

Перейдите в редактор событий и добавьте новое событие:

Условие:

• Collision (Столкновение) между Player и Coin.

Действия:

1. Delete object Coin (Монетка исчезает).
2. Change number variable -> Variable Score -> Add 1 (Увеличиваем счет).

Теперь, когда вы собираете монеты, переменная в памяти меняется. Но игрок этого не видит. Нам нужно вывести это на экран.

Шаг 4: Отображение счета (UI)

1. Создайте текстовый объект ScoreText.
2. Поместите его на слой UI (чтобы он не уезжал вместе с камерой).
3. Добавьте новое событие без условий (выполняется всегда).
4. Действие: Modify the text -> ScoreText -> set to -> "Score: " + ToString(Variable(Score)).

Здесь мы используем выражение ToString(), которое превращает число (значение переменной) в текст, чтобы его можно было склеить со словом "Score: ".

Заключение

Сегодня ваша игра стала намного умнее. Вы узнали:

• Как использовать переменные для хранения счета и жизней.
• Как сделать плавную камеру с помощью математики Lerp.
• Как работают силы и векторы.
• Как оживить интерфейс и объекты с помощью поведений.

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

Финальные штрихи: Создание интерфейса (UI), добавление звука и экспорт игры

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

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

1. Профессиональный интерфейс (UI)

В прошлом уроке мы создали простой текстовый объект для счета. Но вы наверняка заметили проблему: если персонаж убегает далеко вправо, текст счета остается на месте старта и исчезает из вида. Это происходит потому, что текст находится на том же слое, что и игровой мир.

Разделение слоев

Интерфейс (User Interface) должен жить отдельно от игрового мира. В GDevelop для этого используются Слои (Layers).

Представьте, что ваша игра — это бутерброд. Нижний кусок хлеба — это фон. Начинка — это игровой мир. А верхний кусок хлеба — это интерфейс, нарисованный прямо на стекле монитора.

Как настроить слой UI:

1. Откройте панель слоев (справа вверху).
2. Добавьте новый слой и назовите его UI.
3. Переместите его в самый верх списка (чем выше слой в списке, тем позднее он отрисовывается, перекрывая остальные).
4. Выберите ваши объекты интерфейса (текст счета, кнопки, иконки жизней).
5. В панели свойств слева измените параметр Layer с Base Layer на UI.

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

Адаптивность и Якоря (Anchors)

Игроки могут запустить вашу игру на широкоформатном мониторе, на квадратном планшете или на телефоне. Если вы просто поместите кнопку «Меню» в координаты $X=10, Y=10$, на одном экране она будет в углу, а на другом — может оказаться перекрыта вырезом камеры.

Чтобы интерфейс «резиновым» образом подстраивался под размер экрана, используются Якоря (Anchors).

В свойствах любого объекта на слое UI найдите раздел Behaviors -> Add behavior -> Anchor.

Вы можете «примагнитить» объект к краям экрана:

• Top-Left: Жизни, аватар.
• Top-Right: Кнопка паузы, счет.
• Bottom-Center: Инвентарь.

Математика центрирования

Иногда нужно разместить объект (например, надпись «Game Over») идеально по центру экрана, независимо от разрешения. Если вы не используете поведение Anchor, это можно сделать через события, используя формулу центрирования:

$$X_{pos} = \frac{W_{screen}}{2} - \frac{W_{object}}{2}$$

Где:

• $X_{pos}$ — искомая координата $X$ верхнего левого угла объекта.
• $W_{screen}$ — ширина экрана (в GDevelop это выражение SceneWindowWidth()).
• $W_{object}$ — ширина самого объекта (выражение Object.Width()).

Мы делим ширину экрана пополам, чтобы найти центр, а затем вычитаем половину ширины объекта, чтобы его середина совпала с серединой экрана.

2. Звуковое оформление: Аудиодвижок

Звук — это 50% атмосферы игры. В GDevelop работа со звуком делится на две категории: Звуковые эффекты (Sounds) и Музыка (Music).

В чем разница?

• Sounds (Звуки): Короткие файлы (wav, mp3), которые загружаются в память целиком. Используются для прыжков, выстрелов, сбора монет. Они должны срабатывать мгновенно.
• Music (Музыка): Длинные файлы, которые «стримятся» (подгружаются по кусочкам) с диска. Это экономит оперативную память. Используется для фоновых треков.

Каналы (Channels)

Представьте, что у вас есть магнитофон. Если вы включите музыку, а потом захотите послушать аудиокнигу на том же магнитофоне, музыка прервется. В GDevelop «магнитофоны» называются Каналами.

• Если вы используете действие Play a sound (без указания канала), GDevelop сам найдет свободный канал. Это удобно для взрывов и выстрелов, которые могут накладываться друг на друга.
• Если вы используете Play a sound on a channel, вы получаете полный контроль. Обычно для фоновой музыки выделяют Канал 0 или Канал 1.

Пример логики для фоновой музыки:

Условие: At the beginning of the scene (В начале сцены). Действие: Play music file "background.mp3" on channel 1, Loop: Yes, Volume: 50.

Пространственный звук

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

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

$$V_{current} = V_{max} \cdot \left( 1 - \frac{D}{D_{max}} \right)$$

Где:

• $V_{current}$ — текущая громкость звука (от 0 до 100).
• $V_{max}$ — максимальная громкость источника.
• $D$ — текущее расстояние между слушателем (игроком) и источником звука.
• $D_{max}$ — максимальное расстояние, на котором звук еще слышен.

В GDevelop вам не нужно считать это вручную. Просто используйте действие Play a sound at object, и движок сам рассчитает громкость и панораму (лево/право) относительно камеры.

3. Главное меню и переходы

Игра не должна начинаться сразу после запуска. Ей нужно Главное меню.

1. Создайте новую сцену: Назовите её MainMenu. Перетащите её в самый верх списка сцен в менеджере проекта.
2. Добавьте фон и заголовок: Используйте спрайты или текст.
3. Создайте кнопку: Добавьте объект-спрайт PlayButton. У кнопки обычно есть три анимации:
   • Idle (Обычное состояние).
   • Hover (Курсор наведен).
   • Pressed (Нажата).

Логика кнопки: Для оживления кнопки используйте условия взаимодействия с мышью:

• Условие: The cursor/touch is on PlayButton (Курсор на кнопке).

• Действие: Change animation of PlayButton to "Hover".

• Условие: The cursor/touch is on PlayButton И Mouse button released (Кнопка мыши отпущена).

• Действие: Change the scene to "Level1".

4. Экспорт и публикация

Когда игра готова, пришло время показать её миру. GDevelop позволяет экспортировать проект на множество платформ одним кликом.

Web (HTML5)

Самый простой и популярный способ. Игра превращается в набор файлов (index.html, javascript, assets), которые можно загрузить на любой сайт.

1. Нажмите кнопку File (слева вверху) -> Export.
2. Выберите вкладку Web.
3. Выберите Local folder (Локальная папка).
4. Нажмите Export.

Полученную папку можно заархивировать и загрузить на платформы вроде Itch.io или Newgrounds. Игроки смогут играть прямо в браузере, ничего не скачивая.

Desktop (Windows, macOS, Linux)

Чтобы создать настоящий .exe файл, выберите вариант Mobile & Desktop -> Manual build (если вы умеете работать с Electron) или воспользуйтесь облачным сервисом сборки GDevelop (требуется создание аккаунта).

Android

Экспорт на телефоны требует создания файла .apk или .aab. GDevelop предоставляет автоматическую сборку в облаке, что избавляет вас от необходимости устанавливать сложные инструменты вроде Android Studio.

Заключение курса

Поздравляю! Вы прошли путь от установки программы до создания готового дистрибутива игры. Мы изучили:

1. Интерфейс и объекты: Как строить сцену.
2. События: Как программировать логику без кода.
3. Переменные и физику: Как делать игру глубокой и интересной.
4. UI и Звук: Как придать игре законченный вид.

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

Теперь всё зависит от вашей фантазии. Создавайте, экспериментируйте и не бойтесь ошибок. Удачи в разработке вашей игры мечты!