Основы разработки игр на Godot 4 с нуля

Знакомство с Godot и настройка среды разработки

Представьте: вы хотите построить дом, но у вас нет ни инструментов, ни чертежа, ни даже понимания, с какой стороны подойти к стройке. Именно так чувствует себя большинство начинающих разработчиков, когда впервые открывают игровой движок. Экран панелей, вкладок, непонятных кнопок — и ощущение, что вы случайно сели за штурм космического корабля. Но вот что важно: Godot — один из немногих движков, который создан специально для того, чтобы этот барьер был минимальным. И сегодня мы разберёмся, как превратить хаос интерфейса в понятное рабочее пространство.

Почему именно Godot

Среди десятков игровых движков — Unity, Unreal Engine, GameMaker, Construct — Godot выделяется тремя вещами, которые критичны для новичка.

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

Во-вторых, Godot использует собственный язык программирования GDScript, который синтаксически почти идентичен Python. Если вы когда-нибудь писали хотя бы «Hello, world» на Python — вы уже на полпути. Если нет — не волнуйтесь, GDScript один из самых читаемых языков программирования, и мы разберём его подробно в следующей статье.

В-третьих, движок весит менее 100 мегабайт. Скачал, распаковал, запустил — никаких установщиков, драйверов и перезагрузок. Это кажется мелочью, но для человека, который никогда не работал с игровыми движками, отсутствие технических барьеров на старте — огромное преимущество.

> Godot — это бесплатный open-source игровой движок с поддержкой 2D и 3D, использующий язык GDScript и не требующий установки. Актуальная версия на момент написания — Godot 4.4, с активным развитием до версии 4.6.

Скачивание и первый запуск

Перейдём к делу. Godot распространяется с официального сайта godotengine.org. На странице загрузки вы увидите несколько вариантов:

Standard — стандартная версия с поддержкой GDScript и C#

GDScript-only — облегчённая версия только с GDScript (рекомендуется новичкам)

Для нашего курса выбирайте GDScript-only версию — она меньше по размеру и содержит всё необходимое. После скачивания вы получите ZIP-архив. Распакуйте его в удобную папку — и всё. Запускаете исполняемый файл Godot_v4.x, и перед вами открывается Project Manager — менеджер проектов.

Project Manager — это «стартовый экран» движка. Здесь вы будете создавать новые проекты и открывать существующие. Интерфейс минималистичен: слева — список ваших проектов, справа — кнопки создания и импорта.

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

Нажмите New Project. Появится диалог, в котором нужно указать:

Имя проекта — например, MyFirstGame

Путь к папке — где будут храниться файлы проекта

Рендерер — выберите Forward+ для настольных платформ или Mobile для слабых устройств

> Важно: Godot 4.x использует Forward+ как рендерер по умолчанию. Если у вас очень старая видеокарта без поддержки Vulkan, выберите Compatibility (основан на OpenGL).

После создания проекта вы попадёте в редактор — основное рабочее пространство, где и будет строиться ваша игра.

Разбираемся в интерфейсе редактора

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

| Область | Расположение | Назначение | |---|---|---| | Scene (Сцена) | Левая панель | Дерево узлов — иерархия объектов сцены | | Inspector (Инспектор) | Правая панель | Свойства выбранного узла | | FileSystem (Файловая система) | Левый нижний угол | Все файлы проекта | | Viewport (Просмотр) | Центр | Визуальное представление сцены | | Output (Вывод) | Нижняя панель | Логи, ошибки, сообщения отладки |

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

Попробуйте кликнуть по каждой вкладке и понаблюдайте, как меняется центральная область. В режиме 2D вы работаете с двухмерными спрайтами и интерфейсом. В 3D — с трёхмерными моделями и пространством. Вкладка Script открывает редактор кода — мы подробно познакомимся с ним в следующей статье.

Настройка рабочей среды под себя

Godot позволяет гибко настраивать интерфейс. Вот несколько рекомендаций для комфортного старта:

Тема оформления. По умолчанию Godot использует тёмную тему, что удобно для длительных сессий. Если предпочитаете светлую — перейдите в Editor → Editor Settings → Interface → Theme.

Раскладка панелей. Все панели можно перетаскивать, откреплять и комбинировать. Если вы случайно «потеряли» панель — через меню Editor → Editor Settings можно сбросить расположение к стандартному.

Горячие клавиши. Три комбинации, которые стоит запомнить сразу:

Ctrl + S — сохранить текущую сцену

Ctrl + Shift + S — сохранить сцену под другим именем

F5 — запустить игру (Run Project)

Последняя комбинация — F5 — ваш лучший друг на протяжении всего курса. Godot компилирует и запускает проект за секунды, что позволяет тестировать изменения практически мгновенно.

Структура файлов проекта

Когда вы создаёте проект, Godot формирует определённую структуру. Знание этой структуры сэкономит вам часы в будущем:

Файл project.godot — это «паспорт» вашего проекта. В нём хранятся настройки: разрешение экрана, название игры, параметры ввода. Если вы удалите этот файл — проект перестанет открываться. Папка .godot/ содержит внутренний кэш движка — её можно безопасно удалить, и Godot пересоздаст её при следующем запуске.

Что дальше

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

Основы GDScript: синтаксис, переменные и логика для новичков

Когда вы впервые открываете редактор скриптов в Godot и видите пустой файл с мигающим курсором, возникает один и тот же вопрос: «А что я вообще должен туда написать?». Это чувство знакомо каждому, кто начинал программировать — от студентов до профессиональных разработчиков, перешедших с другого языка. Хорошая новость: GDScript создан именно для того, чтобы этот страх исчезал после первых же строк кода. Плохая новости нет — всё действительно просто.

GDScript: язык, созданный для игр

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

Вот как выглядит минимальный скрипт в GDScript:

Разберём построчно. extends Node2D говорит движку, что этот скрипт «наследует» поведение узла Node2D — базового объекта для 2D-сцен. Функция _ready() вызывается один раз при появлении узла на сцене — идеальное место для инициализации. Функция _process(delta) вызывается каждый кадр — здесь происходит игровая логика, движение, проверки. Параметр delta — это время в секундах, прошедшее с предыдущего кадра.

Переменные: хранение данных

Переменные — это контейнеры для данных. В GDScript объявление переменной начинается с ключевого слова var:

GDScript автоматически определяет тип переменной по значению — это называется динамическая типизация. Но вы можете указать тип явно, что считается хорошей практикой:

Основные типы данных:

| Тип | Описание | Пример | |---|---|---| | int | Целое число | 42, -7, 0 | | float | Дробное число | 3.14, -0.5 | | String | Текст | "Привет" | | bool | Логическое значение | true, false | | Array | Список значений | [1, 2, 3] | | Vector2 | 2D-вектор (x, y) | Vector2(10, 20) |

Переменные, объявленные внутри функции, существуют только в ней. Переменные на уровне класса (вне функций) доступны во всех функциях скрипта.

Условия: принятие решений

Игры полны решений: попал снаряд во врага или нет? У игрока достаточно очков для покупки? Здоровье упало до нуля? Для этого используются условные конструкции:

Обратите внимание: в GDScript условие не заключается в скобки (в отличие от C++ или Java), а после двоеточия идёт блок кода с отступом. Это прямое наследие Python.

Для составных условий используются логические операторы:

and — оба условия истинны

or — хотя бы одно условие истинно

not — инверсия условия

Циклы: повторение действий

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

Цикл for — перебирает элементы коллекции:

Цикл while — выполняется, пока условие истинно:

В реальной игровой разработке циклы используются реже, чем вы могли бы ожидать. Основная игровая логика строится на функции _process(), которая и так вызывается каждый кадр — встроенный «цикл» движка.

Функции: организация кода

Функции — это именованные блоки кода, которые можно вызывать многократно. Они решают главную проблему программирования: избежать дублирования.

Функции могут принимать параметры (входные данные) и возвращать значения:

Стрелка -> int после скобок указывает тип возвращаемого значения. Это необязательно, но помогает читать код и ловить ошибки.

Переменные с областью видимости @export

Одна из мощных особенностей GDScript — аннотация @export. Она делает переменную доступной для редактирования прямо в Inspector движка, без изменения кода:

После сохранения скрипта вы увидите поля speed и jump_force в панели Inspector. Теперь вы можете настраивать параметры персонажа, не открывая код — просто двигая ползунки. Это ключевой инструмент для быстрой итерации: изменил значение, запустил игру, оценил результат.

Векторы и движение: мостик к игровой механике

Для работы с позициями и направлениями в Godot используются векторы. Vector2(x, y) — это точка или направление в 2D-пространстве. Вот как выглядит базовое движение объекта:

Этот код читает нажатия клавиш, формирует вектор направления, нормализует его (чтобы диагональное движение не было быстрее горизонтального) и обновляет позицию объекта каждый кадр. Мы подробно разберём эту механику в статье о создании первой игровой механики, но уже сейчас вы можете видеть: GDScript позволяет описать сложное игровое поведение в нескольких строках.

Отладка: ваш лучший инструмент

Когда код не работает так, как ожидается, на помощь приходит print():

Вывод появляется в панели Output внизу редактора. Это простейший, но невероятно эффективный способ отладки. Позже вы познакомитесь с точками останова (breakpoints) и встроенным отладчиком, но на старте print() — ваш главный друг.

GDScript — это не просто «упрощённый Python». Это язык, спроектированный так, чтобы вы тратили время на создание игры, а не на борьбу с синтаксисом. Каждая строка, которую вы написали в этой статье, пригодится вам при создании реальных игровых механик. В следующей статье мы разберём, как устроена система узлов и сцен — фундаментальная архитектура, на которой строится каждая игра в Godot.

Узлы и иерархия сцен: как устроен мир в Godot

Представьте, что вы конструктор LEGO. У вас есть кубики разных форм: одни — стены, другие — окна, третьи — двери. По отдельности каждый кубик — просто пластмассовая деталь. Но когда вы соединяете их в определённом порядке, получается дом. Именно так работает система узлов в Godot. Каждый узел (node) — это базовый строительный блок. А их组合组合组合组合组合组合组合组合 — это ваша игра.

Что такое узел

Узел — это объект с конкретным назначением. Один узел отвечает за отображение картинки (Sprite2D), другой — за физическое тело (CharacterBody2D), третий — за воспроизведение звука (AudioStreamPlayer). У каждого узла есть имя, свойства и возможность прикрепить скрипт.

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

Godot предлагает десятки встроенных узлов. Вот ключевые категории:

| Категория | Примеры узлов | Назначение | |---|---|---| | Базовые | Node, Node2D, Node3D | Основа иерархии | | Отображение | Sprite2D, AnimatedSprite2D, Label | Визуальные объекты | | Физика | CharacterBody2D, RigidBody2D, StaticBody2D | Физическое взаимодействие | | Камера | Camera2D, Camera3D | Управление видом | | Ввод | TouchScreenButton | Управление на мобильных | | Аудио | AudioStreamPlayer, AudioStreamPlayer2D | Звук и музыка | | UI | Button, Control, TextureRect | Интерфейс игрока |

Иерархия: дерево узлов

Узлы в Godot никогда не существуют изолированно. Они всегда расположены в дереве иерархии — структуре, где каждый узел может иметь родителя и детей. Это похоже на генеалогическое дерево или файловую систему с папками и файлами.

Вот как выглядит простейшая сцена персонажа:

Здесь Player — корневой узел. Sprite2D отвечает за внешний вид, CollisionShape2D — за физическую форму для столкновений, Camera2D — за следование камеры за игроком, а AudioStreamPlayer2D — за звуки шагов.

Критически важное правило: дочерний узел наследует трансформации родителя. Если вы переместите Player на 100 пикселей вправо, все его дочерние узлы переместятся вместе с ним. Если повернёте — повернутся тоже. Именно поэтому Sprite2D помещают внутрь CharacterBody2D, а не вешают отдельно: так спрайт всегда следует за физическим телом.

Сцена: самодостаточная единица

Сцена (scene) — это дерево узлов, сохранённое в файл с расширением .tscn. Сцена может быть чем угодно: персонажем, врагом, пулей, меню, уровнем. Главное свойство сцены — переиспользуемость. Создали сцену врага один раз — и можете разместить на уровне десять копий, каждая с независимым поведением.

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

В Godot сцены вкладываются друг в друга. Сцена уровня содержит сцены врагов, которые содержат сцены оружия. Это называется составление сцен (scene composition) — один из ключевых архитектурных принципов движка.

Практика: создаём иерархию персонажа

Давайте создадим простую сцену игрока шаг за шагом.

Нажмите кнопку + рядом с вкладкой Scene (или Ctrl + A).

В поиске введите CharacterBody2D — это узел с физическим телом, которое может сталкиваться с объектами и которое можно перемещать кодом. Нажмите Create.

Кликните правой кнопкой по CharacterBody2D → Add Child Node → найдите Sprite2D. Это узел, который отображает текстуру (картинку).

Снова добавьте дочерний узел к CharacterBody2D — на этот раз CollisionShape2D. Это узел, который задаёт физическую форму для обнаружения столкновений.

В Inspector для CollisionShape2D найдите свойство Shape и выберите RectangleShape2D. Появится синий прямоугольник — это зона столкновений.

Сохраните сцену (Ctrl + S) как player.tscn.

Теперь у вас есть иерархия:

Перетащите любую текстуру из панели FileSystem на Sprite2D — и вы увидите персонажа на экране. Настройте размер CollisionShape2D так, чтобы синий прямоугольник совпадал с визуальным размером спрайта.

Группы и сигналы: связь между узлами

Узлы должны взаимодействовать друг с другом. Два основных механизма для этого — группы и signal (сигналы).

Группы — это теги. Вы можете добавить узел в группу enemies и потом обращаться ко всем узлам этой группы одновременно:

Сигналы — это механизм «издатель-подписчик». Один узел испускает сигнал, когда происходит событие (кнопка нажата, таймер истёк, тело вошло в зону). Другой узел «подписывается» на этот сигнал и выполняет код в ответ.

``gdscript

Узел Timer испускает сигнал timeout, когда время выходит

Sprite2D.visible = false

Изменение свойства таймера

Для обращения к дочерним узлам из кода используется символ Sprite2D.visible = false

Обращение к вложенному узлу

Sprite2D — это сокращение для get_node("Sprite2D"). Обе записи идентичны, но $ используется чаще благодаря краткости.

Система узлов — это не просто техническая деталь движка. Это способ мышления. Опытные разработчики Godot разбивают любую игровую механику на дерево узлов: «Какие компоненты нужны этому объекту? Кто является родителем? Кто — дочерним? Как они общаются?». Когда вы научитесь думать в терминах узлов, проектирование игры станет таким же естественным, как сборка конструктора. В следующей статье мы применим эти знания на практике — создадим первую игровую механику с движением, столкновениями и событиями.

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

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

Подготовка сцены

Прежде чем писать код, нам нужна минимальная сцена. Создайте новый проект в Godot и сформируйте следующую иерархую узлов:

Main — корневой узел сцены, контейнер для всего уровня. Player — персонаж, которым мы будем управлять. Wall — статичная стена, о которую персонаж не сможет пройти. Узел StaticBody2D — это физическое тело, которое не двигается, но может сталкиваться с другими телами.

Для Player назначьте текстуру спрайта и настройте CollisionShape2D с формой RectangleShape2D, совпадающей с размером спрайта. Для Wall сделайте то же самое — можно использовать однотонный прямоугольник.

Движение персонажа

Создайте скрипт для узла Player (правый клик → Attach Script → оставьте настройки по умолчанию). Вот код движения:

Здесь несколько важных моментов. Функция _physics_process(delta) используется вместо _process(delta) для физической логики. Разница в том, что _process вызывается с частотой отрисовки (может колебаться), а _physics_process — с фиксированной частотой (по умолчанию 60 раз в секунду). Для движения и физики стабильный тайминг критичен — без него объекты могут «проскакивать» сквозь стены.

Метод move_and_slide() — это встроенный метод CharacterBody2D, который перемещает тело с учётом столкновений. Если персонаж упрётся в стену, move_and_slide() автоматически скорректирует движение: объект скользит вдоль поверхности, а не проходит сквозь неё.

Настройка Input Actions

Код использует Input.is_action_pressed("move_right") — но откуда движок знает, что такое move_right? Эти действия ввода (input actions) настраиваются в параметрах проекта:

Откройте Project → Project Settings

Перейдите на вкладку Input Map

В поле ввода добавьте новое действие: move_right

Нажмите + рядом с ним и назначьте клавишу D (или стрелку вправо)

Повторите для move_left (клавиша A), move_up (W), move_down (S)

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

Столкновения: обнаружение контакта

Теперь у нас есть движение и стены, через которые персонаж не проходит. Но как узнать, что столкновение произошло, и отреагировать на него?

Для обнаружения столкновений с CharacterBody2D используется метод get_slide_collision_count() и get_slide_collision():

Но для более гибкого обнаружения зон (не обязательно физических столкновений) используются Area2D — узлы, которые реагируют на вход и выход других тел в определённую область.

Area2D: зоны событий

Добавьте к Player дочерний узел Area2D, а к нему — CollisionShape2D с формой чуть больше спрайта. Теперь Area2D будет «чувствовать» приближение других объектов.

Сигналы body_entered и body_exited испускаются, когда физическое тело (CharacterBody2D, RigidBody2D, StaticBody2D) входит в зону или покидает её. Это основа для механик: сбор монет, получение урона, активация триггеров, открытие дверей.

События: связь механик между собой

Представьте сценарий: персонаж подбирает монету, и счёт увеличивается. Вот как это реализуется через сигналы:

В редакторе Godot вы соединяете сигнал coin_collected монеты с методом add_score игрока через вкладку Node (рядом с Inspector). Кликнув на сигнал, вы видите список узлов и их методов — выберите нужный, и связь установлена.

Камера: следование за игроком

Игрок двигается, но без камеры он быстро уйдёт за край экрана. Добавьте дочерний узел Camera2D к Player — теперь камера автоматически следует за персонажем.

Для плавности включите свойство Position Smoothing в Inspector и установите Smoothing Speed на значение около 5–10. Камера будет «догонять» игрока с лёгкой задержкой, что выглядит профессионально.

Если камера должна быть ограничена границами уровня, задайте свойство Limit — минимальные и максимальные координаты.

Анимация: оживление персонажа

Движение без анимации выглядит механически. Для анимации спрайта используйте узел AnimatedSprite2D вместо обычного Sprite2D. Создайте SpriteFrames ресурс с кадрами бега в четырёх направлениях и переключайте анимацию в зависимости от направления движения:

``gdscript @onready var anim = AnimatedSprite2D в теле скрипта (вне функций) вызвало бы ошибку.

Игровой цикл: от ввода к обратной связи

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

Ввод — игрок нажимает клавишу

Обработка — скрипт считывает ввод, вычисляет направление и скорость

Физика — move_and_slide() перемещает тело с учётом столкновений

События — при столкновении с монетой испускается сигнал, обновляется счёт

Отрисовка — Godot отображает новое положение объектов на экране

Этот цикл повторяется 60 раз в секунду. Каждый кадр — новая итерация: ввод, обработка, физика, события, отрисовка. Именно так устроены все игры — от простейшего Pong до открытых миров AAA-проектов.

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

Сборка и запуск прототипа: от идеи к работающей игре

Есть старая шутка среди разработчиков: «Первые 90% игры занимают 90% времени. Оставшиеся 10% — тоже 90% времени». В ней больше правды, чем хотелось бы. Но есть и хорошая новость: путь от идеи до работающего прототипа — это не 90% и не 10%. Это отдельный, вполне конкретный этап, который можно пройти за вечер, если знать последовательность действий. Сегодня мы пройдём его от начала до конца: от «у меня есть идея» до «я нажал F5, и игра запустилась».

Что такое прототип и зачем он нужен

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

Прототип нужен для трёх вещей:

Проверка идеи — интересно ли играть даже в упрощённом виде?

Обратная связь — покажите друзьям, понимают ли они механику без объяснений

Фокус — выясняете, что действительно важно, а что — лишнее

Многие успешные инди-игры начинались как прототипы за выходные. Celeste — платформер, получивший награды — первоначально был прототипом для game jam за четыре дня.

Шаг 1: Формулировка核心-механики

Прежде чем открывать Godot, ответьте на один вопрос: какое одно действие выполняет игрок снова и снова? В Pong — это перемещение платформы. В Flappy Bird — нажатие для прыжка. В Tetris — вращение и размещение фигур.

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

Эта механика проста, но содержит все элементы: ввод, движение, генерация объектов, столкновения, подсчёт очков, состояние «game over».

Шаг 2: Разбиение на задачи

Разбейте прототип на конкретные задачи:

Создать сцену уровня

Реализовать горизонтальное движение игрока

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

Настроить таймер для спавна врагов

Обработать столкновение игрока с врагом

Добавить подсчёт очков и отображение счёта

Реализовать экран Game Over

Каждая задача — это 15–30 минут работы. Не пытайтесь сделать всё сразу. Завершите одну задачу, убедитесь что она работает, переходите к следующей.

Шаг 3: Сцена игрока

Создайте сцену Player.tscn с иерархией:

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

Метод Input.get_axis() — удобный сокращённый способ получить значение от до по двум действиям ввода. Если нажата только move_left, результат . Если move_right — . Если обе или ни одна — .

Шаг 4: Сцена врага

Создайте Enemy.tscn:

Скрипт врага:

Враг просто падает вниз. Когда он уходит за нижний край экрана — удаляется через queue_free(). Это предотвращает накопление объектов в памяти.

Шаг 5: Главная сцена и спавнер

Создайте Main.tscn с корневым узлом Node2D. Добавьте узел Timer с именем SpawnTimer и узел Timer с именем ScoreTimer. Также добавьте Label для отображения счёта.

Скрипт главной сцены:

gdscript func _on_hitbox_body_entered(body): if body.is_in_group("enemies"): get_parent().game_over() gdscript func _on_restart_pressed(): get_tree().reload_current_scene() ``

Метод reload_current_scene() перезагружает текущую сцену — самый быстрый способ рестарта.

Шаг 8: Экспорт игры

Когда прототип работает в редакторе, пришло время собрать его в standalone-приложение — файл, который можно запустить без Godot.

Откройте Project → Export

Нажмите Add → выберите платформу (Windows Desktop для начала)

Укажите путь к исполняемому файлу

Нажмите Export Project

Godot создаст .exe файл (для Windows) размером около 30–50 мегабайт. Это и есть ваша игра — самодостаточное приложение, которое работает на любом компьютере с нужной ОС, без установки Godot.

Для других платформ:

| Платформа | Формат | Особенности | |---|---|---| | Windows | .exe | Самый простой экспорт | | Linux | .x86_64 | Нужно дать права на исполнение | | macOS | .app | Требуется подпись для распространения | | Web | HTML5 | Загружается на itch.io прямо в браузер | | Android | .apk | Нужен Android SDK |

Типичные ловушки при сборке прототипа

Прототип не запускается после экспорта. Частая причина — неправильные пути к ресурсам. Используйте res:// для путей к файлам проекта, а не абсолютные пути.

Игра тормозит. Если враги не удаляются (queue_free() не вызывается), они накапливаются в памяти. Проверяйте, что каждый instantiate() имеет парный queue_free().

Столкновения не работают. Убедитесь, что у всех узлов с физикой есть CollisionShape2D с назначенной формой. Пустой CollisionShape2D без формы — частая ошибка новичков.

Счёт не обновляется. Проверьте, что Label действительно связан с переменной через @onready` и что текст обновляется в той же функции, что и изменение счёта.

От прототипа к игре

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

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

Звук — фоновая музыка, звук столкновения, звук набора очков

Баланс — настроить скорость, частоту спавна, сложность

UI — главное меню, экран паузы, таблица рекордов

Контент — новые типы врагов, бонусы, уровни

Каждый из этих слоёв — отдельная задача, которую можно решить, опираясь на знания из предыдущих статей курса. Узлы, сигналы, GDScript, физика — всё это инструменты, которые вы уже освоили.

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