Manuals
Manuals




This translation is community contributed and may not be up to date. We only maintain the English version of the documentation. Read this manual in English

Defold для користувачів Godot

Якщо ви працювали з Godot, то вже знаєте багато з того, що потрібно для створення гри в Defold. Цей посібник покаже, де ваш досвід допоможе швидко взятися до розробки, а на які відмінності варто звернути увагу, щоб уникнути поширених помилок. Для порівняння ми використали Godot 4.7.

Вступ

Defold — безкоштовний кросплатформний рушій для 2D- та 3D-ігор із редактором для Windows, Linux і macOS. Повний вихідний код рушія й редактора доступний на GitHub. Ви можете зібрати Defold самостійно або завантажити готову версію для своєї ОС.

На перший погляд Defold дуже схожий на Godot. В обох рушіях ви складаєте гру з частин, придатних для повторного використання, а поведінку задаєте скриптами. Godot пропонує багато спеціалізованих вузлів. У Defold набір компонентів менший, проте вони універсальніші, а ігрову логіку реалізують скрипти й модулі Lua. Наприклад, персонаж гравця в Defold може бути ігровим об’єктом (game object) із кількома компонентами (components): спрайтом або моделлю, об’єктом колізій і скриптом.

У Defold особливу увагу приділено малому розміру середовища виконання й ощадливому використанню ресурсів. Це особливо важливо для вебігор і мобільних ігор. Деякі ліміти рушія задають наперед, щоб він міг заздалегідь виділити пам’ять.

Готових ігрових механік та елементів інтерфейсу в Defold може бути менше, ніж у Godot, але того самого результату можна досягти, поєднуючи базові компоненти Defold або розширюючи їх. Розробники Defold прагнуть зберегти ядро рушія якомога компактнішим. Ви можете додатково зменшити його, вилучивши непотрібні можливості, або розширити нативними розширеннями та модулями Lua. На Defold Asset Portal є сотні модулів, бібліотек і розширень, які допоможуть, наприклад, створити складний інтерфейс чи конвеєр рендерингу або спростити окремі завдання розробки.

Докладніше про можливості Defold читайте на сторінці рушія.

Установлення

  1. Завантажте Defold для своєї операційної системи зі сторінки завантажень.
  2. Розпакуйте архів і запустіть редактор.

Щоб створити й запустити перший проєкт, вам не доведеться окремо встановлювати програму для керування проєктами чи шаблони експорту. Інструкції для вашої платформи наведено в посібнику зі встановлення.

Defold можна оновити безпосередньо з редактора. Коли оновлюєте наявний проєкт, перегляньте примітки до випуску й перевірте гру на цільових платформах.

Екран привітання

Під час запуску Defold показує екран привітання, де можна відкрити нещодавній проєкт або створити новий. Він виконує приблизно ту саму роль, що й менеджер проєктів Godot.

Менеджер проєктів Godot і екран привітання Defold

Новий проєкт у Defold можна створити з одного з таких розділів:

  • Templates — порожні шаблони та шаблони для окремих платформ.
  • Tutorials — вступні проєкти з покроковими інструкціями.
  • Samples — приклади та стартові набори, які можна запустити й дослідити.

Менеджер проєктів Godot і екран привітання Defold

У розділі Samples є стартові проєкти та приклади, подібні до стартових наборів і прикладів із Godot Asset Store:

Менеджер проєктів Godot і екран привітання Defold

Привіт, світе

Це простий спосіб швидко зробити щось у Defold: виконайте ці кроки, а потім поверніться до решти посібника.

  1. Виберіть порожній проєкт у Templates, укажіть його назву в Title, виберіть розташування та створіть його, натиснувши Create New Project. Він відкриється в редакторі Defold. Привіт, світе: крок 1
  2. Ліворуч, на панелі Assets, відкрийте теку main і двічі клацніть main.collection, щоб відкрити цей файл.
  3. Праворуч, на панелі Outline, клацніть правою кнопкою миші Collection і виберіть Add Game Object. Привіт, світе: крок 2
  4. Клацніть правою кнопкою миші створений ігровий об’єкт (game object) go і виберіть Add Component, а потім Label. Привіт, світе: крок 3
  5. Унизу ліворуч, на панелі Properties, уведіть щось у властивість Text.
  6. У головній центральній області перегляду сцени перетягніть напис приблизно в позицію (480,320,0) або змініть її в Properties: Position. Привіт, світе: крок 4
  7. Змінивши позицію напису, збережіть проєкт, вибравши File -> Save All або натиснувши Ctrl+S (Cmd+S на Mac).
  8. Зберіть проєкт, вибравши Project -> Build або натиснувши Ctrl+B (Cmd+B на Mac). Привіт, світе: крок 5

Ви щойно зібрали свій перший проєкт у Defold і маєте побачити свій текст у вікні. Поняття ігрового об’єкта та компонента мають бути вам знайомі. Нижче пояснено колекції (collections), панелі Outline і Properties та причину, з якої нам потрібно було трохи перемістити напис угору й праворуч.


Огляд редактора Defold

Основні панелі ви, найімовірніше, впізнаєте, хоча вони мають інші назви й розташування. Для наочного порівняння ми розташували панелі редактора Godot приблизно так, як вони розташовані в Defold за замовчуванням:

Огляд редактора Godot Огляд редактора Defold

Godot Defold Призначення панелі в редакторі Defold
Панель FileSystem Assets Керування файлами й теками проєкту. Їхня структура точно відповідає каталогу проєкту на диску.
Область перегляду 2D/3D та редактори ресурсів Main Editor Вигляд залежить від відкритого файлу: колекції, GUI, атласу, скрипту тощо. Область можна розділити на дві панелі.
Панель Scene Outline Показує структуру поточного ресурсу. Глобального дерева сцени, як під час виконання в Godot, тут немає.
Inspector Properties Показує властивості вибраного об’єкта, компонента чи ресурсу.
Output і Debugger Tools Містить вкладки Console, Build Errors і Search Results, а також налагоджувач.
Інтеграція з системою керування версіями Changed Files Показує зміни, якщо проєкт використовує Git.

У правому верхньому куті 3D-редактора Defold є панель інструментів. Докладніше про неї читайте в посібнику з редагування сцени.

Орієнтація сцени у 2D та 3D

Вигляд сцени можна використовувати для роботи як у 2D, так і в 3D. Типове налаштування 2D використовує ортографічний вигляд із сіткою на площині X-Y.

Ортографічний вигляд 2D-сцени в Defold

Для роботи в 3D вимкніть 2D на панелі інструментів. Це змінить орієнтацію вигляду та налаштування сітки на 3D. У меню Grid Settings можна налаштувати площину та вигляд сітки.

Ортографічний вигляд 3D-сцени в Defold

Для перспективного вигляду ввімкніть Perspective camera на панелі інструментів.

Перспективний вигляд 3D-сцени в Defold

Змінити вигляд також можна через меню View.

Панелі

Панелі Defold не можна відкріпити в окремі вікна, але ви можете змінювати їхні розміри, перетягуючи межі. Панелі можна показувати й приховувати клавішами F6, F7 та F8 або через меню View:

Керування видимістю панелей

Координати

Якщо ви використовуєте стандартний скрипт рендерингу, а в колекції Defold немає компонента камери, у 2D точка (0, 0) буде в нижньому лівому куті вікна гри. Додатний напрямок осі Y — угору, а осі X — праворуч.

У звичних екранних координатах Godot у 2D додатний напрямок осі Y — униз. Зважайте на це, коли переносите координати об’єктів або код руху.

Відмінність між системами координат Defold і Godot у 2D

У системі координат Godot у 3D додатний напрямок осі Y — угору, як і в Defold. Defold використовує єдину тривимірну систему координат і для 2D-, і для 3D-ігор. У типовій 2D-грі дія відбувається в площині XY з ортографічною проєкцією. За потреби камеру можна налаштувати інакше.

Подібність систем координат Defold і Godot у 3D

Докладніше про редактор Defold читайте в посібнику з огляду редактора.


Ключові поняття

У Godot ви будуєте сцени з вузлів. У Defold ви працюєте з компонентами, ігровими об’єктами та колекціями (collections) ігрових об’єктів.

Наприклад, у Godot ви можете створити персонажа з вузла Node2D із дочірнім вузлом Sprite2D, прикріпити скрипт до кореневого вузла й додати персонажа до своєї першої сцени (Scene). У Defold персонаж може бути ігровим об’єктом із компонентами Sprite і Script. Такий об’єкт ви додаєте до колекції.

Вузли Godot у порівнянні з ігровими об’єктами й компонентами Defold

Ці поняття докладно описано в посібнику про будівельні блоки.

Ігрові об’єкти

У Defold ігровий об’єкт є контейнером для компонентів. Кожен такий об’єкт має:

  • ідентифікатор
  • трансформацію (позицію, обертання, масштаб)

Ігровий об’єкт може виконувати приблизно ту саму роль, що й Node2D або Node3D у Godot. У Defold немає окремого типу ігрових об’єктів для 2D: усі ігрові об’єкти мають тривимірну трансформацію, зокрема й у 2D-іграх.

У Defold один ігровий об’єкт можна зробити дочірнім щодо іншого, щоб він успадкував трансформацію батьківського об’єкта. Ці зв’язки можна встановити в колекції або змінювати під час виконання. Призначення батьківського об’єкта не змінює адресу ігрового об’єкта.

У колекції ігровий об’єкт можна визначити як вбудований безпосередньо у файлі .collection або додати його як посилання на прототип .go для повторного використання. Редагування визначення вбудованого об’єкта змінює відповідну колекцію й не зачіпає інших незалежно визначених об’єктів. Зміни прототипу .go поширюються на екземпляри, які на нього посилаються, з урахуванням перевизначених властивостей кожного екземпляра. Кілька об’єктів, зокрема й вбудованих, можуть посилатися на той самий ресурс компонента. Зміна цього ресурсу може вплинути на всі об’єкти, що його використовують. Якщо колекцію використовують повторно, зміни у вбудованих об’єктах з’являться всюди, де є посилання на цю колекцію.

Компоненти

Компоненти — спеціалізовані будівельні блоки. Вони, серед іншого, визначають вигляд ігрових об’єктів, надають їм фізичних властивостей, відтворюють звук або задають поведінку.

Щоб показати зображення, додайте до ігрового об’єкта компонент Sprite. Для відтворення звуку використайте Sound, а для виконання коду Lua — Script.

Компоненти належать ігровим об’єктам і не можуть мати дочірніх компонентів. Щоб побудувати ієрархію, установіть батьківсько-дочірні зв’язки між ігровими об’єктами в колекції.

Прикріпити скрипт до компонента, щоб змінити його поведінку, як у Godot, теж не можна. Ви можете налаштувати компонент на панелі Properties або створити власний за допомогою нативних розширень — подібно до GDExtension у Godot. Прикладами власних компонентів Defold є офіційні Rive та Spine, а також розроблені спільнотою Sprite Loop та Object Interpolation.

Скрипт у Defold — окремий компонент, який можна додати до будь-якого ігрового об’єкта. Один ігровий об’єкт може містити кілька компонентів, зокрема й кілька скриптів.

Компоненти не вкладені один в один і відокремлені від користувацьких скриптів. Завдяки такій організації, орієнтованій на дані, Defold може ефективно розміщувати компоненти в пам’яті.

Вузол Godot Компонент Defold Примітки
Sprite2D / AnimatedSprite2D Спрайт Відображає 2D-текстури й покадрову анімацію з атласу (текстури з кількома зображеннями) або джерела плиток.
Area2D / RigidBody2D / StaticBody2D та їхні 3D-відповідники Об’єкт колізій Обробляє фізичні взаємодії й тригери. Форми колізій визначають безпосередньо в цьому компоненті, а не в окремих дочірніх вузлах. Можна вибрати статичний, динамічний, кінематичний або тригерний тип.
Скрипт .gd, прикріплений до вузла Script Містить код Lua для ігрової логіки, обробки введення та керування іншими компонентами й ігровими об’єктами.
TileMapLayer Карта плиток Відображає карту на сітці, використовуючи джерело плиток і шари карти.
Label Текстовий вузол GUI Для тексту інтерфейсу використовуйте текстовий вузол GUI. Для тексту в ігровому світі використовуйте компонент Label.
AudioStreamPlayer Звук Відтворює звук. Можна налаштувати швидкість (Speed), панорамування (Pan) і підсилення (Gain).
Camera2D / Camera3D Камера Підтримує ортографічну й перспективну проєкції.
Ієрархія Control / CanvasLayer GUI Усередині компонента GUI в Defold є окрема ієрархія вузлів (наприклад, Box, Text і Pie), а для керування інтерфейсом передбачено окремий скрипт .gui_script.
MeshInstance3D Модель або меш Model відображає імпортовані 3D-ресурси, а Mesh підтримує власну геометрію з буфера.
CPUParticles2D / GPUParticles2D та їхні 3D-відповідники Ефект частинок Випускає 2D- або 3D-частинки, налаштовані в редакторі частинок Defold.
PackedScene.instantiate() Factory / Collection Factory У Defold є окремі компоненти, у яких ви визначаєте, які ігрові об’єкти або колекції можна створювати під час виконання.

Колекції та світи

Колекція описує ігрові об’єкти, їхні компоненти та батьківсько-дочірні зв’язки. Колекції можна вкладати в інші колекції, щоб повторно використовувати групу об’єктів, подібно до вкладених сцен у Godot. Defold не має такого універсального механізму успадкування сцен, як у Godot. Натомість можна повторно використовувати прототипи й колекції, а екземпляри налаштовувати через властивості або скрипти.

Файл колекції не стає окремою сутністю під час виконання. Немає ані об’єкта колекції, у якого можна викликати методи, ані кореневого вузла, що представляв би саму колекцію. Файл містить визначення, за якими Defold під час виконання створює ігрові об’єкти, компоненти та їхню ієрархію.

Під час запуску гри Defold читає файл game.project. Параметр Bootstrap ▸ Main Collection вказує, яку колекцію завантажити першою. Так створюється початковий ігровий світ. Об’єкти із вкладених колекцій стають частиною цього самого світу.

Компонент фабрика колекції (Collection Factory) створює групу ігрових об’єктів та їхні компоненти в наявному світі, до якого належить сама фабрика.

Натомість проксі колекції (Collection Proxy) завантажує окрему колекцію та створює новий світ із власним простором адрес і окремою симуляцією фізики. Це важливо враховувати, наприклад, коли потрібно створити ворога, який взаємодіятиме з геометрією поточного рівня, або завантажити зовсім новий рівень, можливо, асинхронно. Обидва випадки розглянуто нижче.

Godot використовує PackedScene і для створення екземплярів, і для перемикання сцен. Перемикання сцен за допомогою SceneTree можна порівняти із завантаженням окремого світу через проксі колекції.

Основні відповідники наведено в таблиці:

Godot Defold Примітки
Node3D із дочірніми вузлами Ігровий об’єкт із компонентами Компоненти надають можливості та визначають поведінку. Ігрові об’єкти мають трансформацію й ідентифікатор.
Трансформація Node2D / Node3D Трансформація ігрового об’єкта Вбудована в кожен ігровий об’єкт.
Сцена / PackedScene Прототип ігрового об’єкта (.go) або колекція (.collection) Прототип описує один об’єкт, а колекція — групу об’єктів та їхню ієрархію.
PackedScene.instantiate() Фабрика або фабрика колекції Створює ігровий об’єкт або групу ігрових об’єктів у поточному світі й повертає їхні ідентифікатори.
Перемикання сцен за допомогою SceneTree + PackedScene.instantiate() Проксі колекції Завантажує колекцію, створює окремий світ і розміщує в ньому ігрові об’єкти.

Написання коду

У редакторі Defold є вбудований текстовий редактор для текстових файлів і скриптів. Серед його можливостей — автодоповнення, форматування й панель Structure, яка показує структуру даних і функцій у файлі. Докладніше читайте в розділі «Використання вбудованого редактора коду».

Усі текстові файли та скрипти Defold можна також відкривати в зовнішньому редакторі. Defold має низку можливостей для інтеграції із зовнішніми інструментами, як-от VS Code, і роботи з ними. Докладніше читайте в розділі «Використання зовнішнього редактора коду».

Lua та скрипти

Ігрові скрипти Defold пишуть мовою Lua. Вона може нагадувати GDScript, але між ними є істотні відмінності. Defold також підтримує Teal — статично типізований діалект Lua. Як і GDExtension у Godot, нативні розширення Defold дають змогу використовувати інші мови: залежно від цільової платформи це C, C++, C#, Objective-C, Java чи JavaScript. Про розширення поговоримо окремо.

У Defold ви переважно працюватимете з такими файлами Lua:

Файл Призначення
.script Ігрова логіка та поведінка. API go, factory, sprite, tilemap, physics та інші дають змогу керувати ігровими об’єктами й компонентами.
.gui_script Скрипт для GUI, який визначає поведінку інтерфейсу через API gui.
.render_script Керування рендерингом через API render.
.lua Модулі Lua для повторного використання, наприклад бібліотеки коду й допоміжні скрипти. Їх завантажують за допомогою require().

Таблиці Lua можуть містити дані, функції або те й інше. Щоб упорядкувати код, не обов’язково відтворювати ієрархію класів GDScript. Винесіть спільну логіку в модуль і викликайте її зі скрипту, який керує потрібною поведінкою.

Скрипти Defold сумісні з Lua 5.1. Про відмінності мови й особливості платформ читайте в посібнику «Lua в Defold».

Життєвий цикл застосунку

Гра в Defold починається з етапу ініціалізації та закінчується етапом завершення. Між ними щокадру виконується цикл оновлення: рушій оновлює трансформації й компоненти, виконує код і обробляє повідомлення.

Життєвий цикл застосунку в Defold

Як і в інших ігрових рушіях, зокрема Godot, у Defold на різних етапах життєвого циклу застосунку рушій викликає відповідні функції скриптів Lua. Назви зворотних викликів у Defold інші, проте їхнє призначення вам уже знайоме:

Godot Defold Призначення
_ready() init(self) Ініціалізація даних екземпляра й отримання фокуса введення за потреби.
_process(delta) update(self, dt) Оновлення раз на кадр.
_physics_process(delta) fixed_update(self, dt) Оновлення з фіксованим часовим кроком, якщо його ввімкнено.
_input(event) on_input(self, action_id, action) Обробка введення, переданого слухачам цього об’єкта.
Зворотний виклик сигналу on_message(self, message_id, message, sender) Отримання повідомлень від скриптів або компонентів рушія.
_exit_tree() final(self) Очищення під час завершення роботи екземпляра скрипту.

У Godot функція _ready() дочірніх вузлів виконується раніше, ніж у батьківського вузла. Defold не гарантує порядку ініціалізації чи оновлення ігрових об’єктів і компонентів. Координуйте їх через повідомлення: не покладайтеся на те, що init() певного об’єкта виконається першим.

Щоб використовувати fixed_update(), задайте для Engine ▸ Fixed Update Frequency у файлі game.project додатне значення, наприклад 60, і ввімкніть Physics ▸ Use Fixed Timestep.

У Defold також є late_update(self, dt) для дій, які потрібно виконати після звичайних оновлень і перед рендерингом, наприклад для коригування положення камери. За потреби після цього рушій може ще раз оновити трансформації.

Вимкнення компонента та його видалення — різні операції.

Повну послідовність етапів та зворотні виклики для кожного типу скрипту наведено в посібнику про життєвий цикл застосунку.

Дані екземпляра й локальні дані

Кожен екземпляр компонента-скрипту отримує у зворотних викликах власний self. У ньому можна зберігати стан екземпляра, наприклад self.health або self.target. Навіть два компоненти-скрипти одного ігрового об’єкта мають окремі значення self. Значення self має тип userdata і дає змогу звертатися до полів, як у таблиці, але таблицею Lua не є. Тому такі операції, як pairs(self), не працюють. У Godot подібну роль відіграють змінні екземпляра (var).

Godot розглядає кожен файл .gd як визначення класу. Якщо прикріпити один файл .gd до 10 ворогів, Godot створить 10 окремих екземплярів класу. Кожен матиме власну копію змінних, оголошених через var на верхньому рівні.

Defold виконує файл .script як блок коду Lua, коли завантажує ресурс скрипту. Кожен екземпляр компонента-скрипту отримує власний self у зворотних викликах життєвого циклу, зокрема в init(self) та update(self, dt).

Натомість локальна змінна, оголошена на верхньому рівні файлу .script у Defold, є спільною для всіх екземплярів цього скрипту. Такій локальній змінній на рівні файлу Defold у Godot відповідає статична змінна (static var).

Відмінність між даними екземпляра та локальними даними в Defold

У наведеному прикладі зміна self.has_shield на true в одному екземплярі не вплине на інші. Натомість локальна змінна color спільна для всіх екземплярів, які використовують цей файл скрипту, тож її зміна може позначитися на кожному з них.

Властивості

Щоб оголосити властивість екземпляра, доступну для редагування, використовуйте go.property(). У скрипті до неї можна звернутися через self. Як і @export у Godot, це дає змогу редагувати значення в редакторі. У Defold такі властивості видно на панелі Properties:

Властивості в редакторі Defold

Для порівняння, ось скрипт GDScript, прикріплений до Node3D у Godot:

extends Node3D

@export var speed: float = 100.0

func _process(delta):
    position.x += speed * delta

А ось скрипт на Lua, доданий у Defold як компонент-скрипт:

go.property("speed", 100)

function update(self, dt)
    local position = go.get_position()
    position.x = position.x + self.speed * dt
    go.set_position(position)
end

У Lua ця властивість доступна як self.speed. Її значення можна також передати під час створення об’єкта. У Defold трансформації використовують vector3 навіть у 2D, тож координату Z також потрібно вказувати.

Підтримувані типи властивостей перелічено в посібнику «Властивості скриптів», а додаткові приклади є в посібнику «Скрипти».


Повідомлення та адресація

У Godot сигнали дають змогу об’єкту сповістити про подію підключених слухачів. У Defold скрипти зазвичай спілкуються, надсилаючи повідомлення на адресу ігрового об’єкта або компонента.

У Defold з будь-якого скрипту можна надіслати повідомлення за допомогою функції msg.post(), а отримати й обробити повідомлення можна у зворотному виклику on_message() скрипту.

Передавання повідомлень у Defold

Наприклад, персонаж гравця може повідомити інтерфейс (HUD) про зміну рахунку.

У Godot вузол Player (Node2D) використовує скрипт player.gd. Сусідній вузол GUI (CanvasLayer) використовує gui.gd і містить вузол Label із назвою ScoreText:

Налаштування сигналів у Godot

У Defold ігровий об’єкт player має скрипт player.script. Ігровий об’єкт hud має компонент gui з текстовим вузлом score і скриптом hud.gui_script:

Налаштування обміну повідомленнями в Defold

Надсилання повідомлень

У Godot вузли Player і GUI мають спільного батька. Player підключає свій сигнал score_changed до методу в скрипті GUI. Цей метод оновлює напис Label.

GDScript, файл player.gd:

extends Node2D

signal score_changed(value: int)
var score: int = 0

func _ready() -> void:
    score_changed.connect(get_node("../GUI").set_score)

func collect() -> void:
    score += 1
    score_changed.emit(score)

func _unhandled_input(event: InputEvent) -> void:
    if event is InputEventKey and event.pressed and not event.echo:
        if event.keycode == KEY_SPACE:
            collect()

У Godot вузол Player оголошує сигнал score_changed. Під час _ready() він підключає цей сигнал до методу set_score() у скрипті GUI. З кожним викликом collect() рахунок зростає, а сигнал передає нове значення.

У Defold прив’яжіть клавішу Space до дії collect у прив’язках введення. Об’єкт player ініціалізує рахунок у init() і запитує фокус введення, щоб отримувати події введення. Під час виклику collect(self) скрипт збільшує рахунок і надсилає повідомлення score_changed на адресу /hud#gui, передаючи нове значення в таблиці повідомлення.

Lua, файл player.script:

function init(self)
    self.score = 0
    msg.post(".", "acquire_input_focus")
end

local function collect(self)
    self.score = self.score + 1
    msg.post("/hud#gui", "score_changed", { value = self.score })
end

function on_input(self, action_id, action)
    if action_id == hash("collect") and action.pressed then
        collect(self)
    end
end

У Defold гравцеві не потрібно заздалегідь підключати сигнал до GUI, як у Godot. Достатньо надіслати повідомлення на адресу отримувача. Поєднуючи повідомлення з відносною адресацією Defold, можна писати функції й скрипти для повторного використання.

Отримання та обробка повідомлень

Далі GUI отримує значення й оновлює текст рахунку.

GDScript, файл gui.gd, прикріплений до вузла GUI (CanvasLayer):

extends CanvasLayer

func set_score(value: int) -> void:
    $ScoreText.text = str(value)

Скрипт GUI отримує передане сигналом значення через set_score(), а потім оновлює дочірній вузол Label із назвою ScoreText. Гравець не звертається до напису напряму й не змінює його.

Скрипт GUI у Defold спочатку отримує текстовий вузол рахунку через gui.get_node(). Коли компонент GUI отримує повідомлення, функція on_message() перевіряє його ідентифікатор. Якщо це score_changed, скрипт читає значення message.value і оновлює текст через gui.set_text().

Lua, файл hud.gui_script, призначений компоненту GUI:

function init(self)
    self.score_node = gui.get_node("score")
end

function on_message(self, message_id, message, sender)
    if message_id == hash("score_changed") then
        gui.set_text(self.score_node, tostring(message.value))
    end
end

У Defold повідомлення адресовано саме компоненту GUI. Воно не надходить безпосередньо до текстового вузла рахунку. Скрипт GUI, який отримав повідомлення, вирішує, як його обробити та який текстовий вузол оновити.

На обох знімках екрана видно початковий текст Score: 0. Коли рахунок змінюється, скрипти в цих прикладах замінюють весь напис числовим значенням.

Функція msg.post() ставить повідомлення в чергу для подальшої доставки. Вона не викликає отримувача негайно й не повертає результату з його скрипту. Повідомлення часто доставляється в тому самому кадрі, але гарантії немає: кількість проходів обробки черги обмежена, тож довгий ланцюг повідомлень може тривати й у наступному кадрі. Якщо отримувачеві потрібно відповісти, він може надіслати нове повідомлення на URL-адресу відправника, передану в on_message(). Докладніше читайте в розділі «Ланцюги повідомлень».

Є відмінність і в спілкуванні з кількома слухачами. До сигналу Godot можна підключити кілька методів. Коли вузол випромінює сигнал, сповіщення отримують усі підключені слухачі. Повідомлення Defold надсилається на конкретну адресу. Щоб сповістити кількох отримувачів, можна надіслати кожному окреме повідомлення або реалізувати у грі систему підписок.

Як знайти об’єкт: адресація в Defold

У Defold немає універсального відповідника get_node(), який повертав би об’єкт Lua, що представляє інший екземпляр скрипту. Натомість ви передаєте ідентифікатор або URL функції API рушія, наприклад go.get_position(), go.set() чи msg.post().

URL у Defold складається з трьох частин:

socket:/path#component
  • Сокет (socket) визначає світ, наприклад світ стартової колекції або світ, завантажений через проксі колекції.
  • Шлях (path) визначає ігровий об’єкт у цьому світі.
  • Компонент (component) визначає компонент цього об’єкта.

Можна вказати повну URL-адресу або пропустити частину полів і отримати відносну адресу. Наприклад, щоб звернутися зі скрипту до компонента того самого ігрового об’єкта, достатньо вказати лише компонент. Поширені форми адрес:

Адреса Значення
"#sprite" Компонент sprite поточного ігрового об’єкта.
"/player#controller" Компонент controller об’єкта player у поточному світі.
"level:/player#controller" Компонент controller у завантаженому світі з назвою level.
"." Скорочена адреса поточного ігрового об’єкта (Game Object). Повідомлення отримують його компоненти.
"#" Скорочена адреса поточного компонента-скрипту (Script).

Вкладені колекції можуть додавати префікси до шляхів об’єктів. Батьківсько-дочірні зв’язки, за якими успадковуються трансформації, не змінюють адресу об’єкта.

Для динамічно створених об’єктів зберігайте в коді ідентифікатори, які повертають factory.create() та collectionfactory.create().

У Defold немає вбудованого відповідника групам Godot, за якими ігровий код знаходить об’єкти чи викликає call_group(). Для цього знадобиться власний реєстр об’єктів або механізм пересилання повідомлень.

Фізичні групи об’єктів колізій у Defold слугують фільтрами зіткнень: маска визначає, з якими іншими групами взаємодіє група об’єкта. Ці групи не пов’язані з передаванням повідомлень.

Радимо на початку ознайомитися з посібниками з адресації та передавання повідомлень. У них є відповіді на багато запитань, які виникають під час роботи над першим проєктом.


Автозавантаження та спільний стан

Модулі Lua також дають змогу викликати функції Lua напряму, без обміну повідомленнями через систему Defold.

Якщо в Godot ви зберігаєте спільні дані за допомогою Autoload, у Defold цю роль може виконувати модуль Lua. Збережіть модуль, наприклад, у файлі modules/game_state.lua, а потім завантажте його за допомогою require "modules.game_state".

Приклад на GDScript, де файл game_state.gd зареєстровано як Autoload із назвою GameState:

extends Node
var score: int = 0

Відповідник на Lua у файлі modules/game_state.lua:

local M = { score = 0 }
return M

Тепер інший скрипт може скористатися спільними даними:

GDScript:

func add_point():
    GameState.score += 1

Lua:

local game_state = require "modules.game_state"

local function add_point()
    game_state.score = game_state.score + 1
end

Функція require() кешує модуль, тож код, який його завантажує, отримує ту саму таблицю. Скрипти ігрових об’єктів, GUI та рендерингу використовують спільний стан Lua. Вивантаження проксі колекції не скидає дані модуля. Їх можна явно скинути на початку нової гри.

Модуль Lua в Defold не є ігровим об’єктом і не отримує зворотних викликів життєвого циклу, повідомлень чи введення. Якщо ви використовували Autoload для щокадрової логіки, відтворення звуків або керування переходами між рівнями, помістіть цю поведінку в скрипт об’єкта колекції. Можна також визначити функцію в модулі та явно викликати її зі зворотних викликів життєвого циклу в скриптах.

Модуль Lua my_module:

local M = {}

function M.init(self)
    print("My init")
end

return M

Скрипт Lua:

local my_module = require "my_module"

function init(self)
    my_module.init(self)
end

Для даних, окремих для кожного екземпляра, модуль може повертати функцію, що створює нову таблицю. Цю таблицю можна зберігати в self. Докладніше про модулі та особливості їх гарячого перезавантаження читайте в посібнику про модулі.


Створення об’єктів і завантаження рівнів

Фабрики

Щоб створювати окремі ігрові об’єкти в Defold, додайте компонент Factory і вкажіть потрібний файл .go у властивості Prototype.

Для групи об’єктів додайте Collection Factory і вкажіть потрібний файл .collection. Фабрика колекції створить об’єкти, зберігши їхні батьківсько-дочірні зв’язки.

У наведеному нижче прикладі для Godot вузол Node2D розташовано в початку координат сцени. Його скрипт створює екземпляри куль:

GDScript:

extends Node2D

const BULLET = preload("res://bullet.tscn")

func spawn_bullet():
    var bullet = BULLET.instantiate()
    bullet.position = Vector2(200, 100)
    add_child(bullet)
    return bullet

У Defold ми додали до ігрового об’єкта компонент-фабрику з ідентифікатором bullet_factory. Функція factory.create() створює екземпляр ігрового об’єкта, на який посилається фабрика у властивості Prototype:

Налаштування фабрики в Defold

У прикладі на знімку екрана фабрику викликають із init(). Наступна допоміжна функція показує, як передати позицію нового об’єкта й повернути його ідентифікатор:

Lua:

local function spawn_bullet()
    local position = vmath.vector3(200, 100, 0)
    local id = factory.create("#bullet_factory", position)
    return id
end

Функція Defold повертає ідентифікатор об’єкта, а не об’єкт із методами. Передайте цей ідентифікатор функціям із API go або складіть URL компонента за допомогою msg.url(nil, id, "controller"), якщо створений об’єкт має компонент-скрипт із назвою controller.

Фабрика колекції повертає таблицю, яка зіставляє ідентифікатори об’єктів у прототипі з ідентифікаторами створених об’єктів. Збережіть її, щоб згодом видалити ці об’єкти:

local ids = collectionfactory.create("#collection_factory")
-- Later, when the spawned objects are no longer needed:
go.delete(ids)

На відміну від queue_free() у Godot, функція go.delete(id) за замовчуванням не видаляє дочірні об’єкти рекурсивно. Щоб видалити об’єкт та всіх його поточних нащадків, використовуйте go.delete(id, true). Якщо передати таблицю фабрики у go.delete(ids), функція видалить перелічені в ній об’єкти, але збереже інші об’єкти, які стали їхніми нащадками згодом. Рекурсивне видалення відомого кореневого об’єкта, навпаки, видалить усі об’єкти, які на той момент йому підпорядковані. Див. go.delete().

Defold заздалегідь резервує місце для ігрових об’єктів і компонентів. Якщо об’єкт не вдається створити через досягнення ліміту, перевірте Collection ▸ Max Instances і ліміти відповідних компонентів у game.project. Збільшення всіх лімітів збільшує й споживання пам’яті.

Про властивості, трансформації та динамічне завантаження читайте в посібниках про фабрики та фабрики колекцій.

Проксі колекцій

Щоб завантажувати колекції в Defold, наприклад для переходу між рівнями, додайте компонент Collection Proxy до об’єкта, який залишається в грі між переходами. У властивості Collection виберіть відповідний файл .collection.

Налаштування проксі колекції в Defold

Надішліть проксі повідомлення "load" або "async_load" за допомогою msg.post(). Після завантаження проксі відповість повідомленням "proxy_loaded". Потім можна надіслати "init" та "enable" для ініціалізації й запуску завантаженого світу. Використайте адресу, яку on_message отримав у параметрі sender.

Так ви самі визначаєте, які світи завантажені та які працюють. Поточна сцена не замінюється автоматично, як під час зміни сцени в Godot. Щоб вилучити світ, надішліть повідомлення "unload" проксі відповідної колекції. Перш ніж вивантажити світ, проксі сам вимкне його й завершить його роботу, а потім відповість повідомленням "proxy_unloaded". Якщо потрібно керувати цими етапами окремо, ви можете самі надіслати "disable" та "final".

Об’єкти колізій у різних світах, завантажених через проксі, не стикаються між собою, навіть якщо обидва світи завантажено одночасно й видно на екрані. Проте ігрові об’єкти та компоненти можуть обмінюватися повідомленнями, якщо в URL вказано сокет світу отримувача.

Перш ніж реалізовувати переходи між рівнями, прочитайте посібник про проксі колекцій. У ньому розглянуто завантаження й вивантаження, пересилання введення та керування частотою оновлення завантаженого світу.

Ресурси й файли проєкту

Проєкт Defold — це тека з файлом game.project, скриптами та ресурсами. Панель Assets відображає структуру цієї теки. Більшість визначень ресурсів Defold зберігаються в текстових файлах, тому їхні зміни можна переглядати в системі керування версіями.

Коли ви збираєте або пакуєте гру, Defold перетворює вихідні ресурси на формати, призначені для середовища виконання. Ресурси, на які посилаються головна колекція, фабрики й проксі колекцій, утворюють дерево залежностей. Файл, на який немає посилань, не потрапить до пакета лише тому, що лежить у теці проєкту.

У Defold немає єдиного універсального відповідника власним класам Resource і файлам .tres у Godot. Для ресурсів, з якими працює рушій, використовуйте типи ресурсів Defold, а для власних ігрових даних — таблиці Lua або файли даних. API resource дає змогу створювати та змінювати ресурси підтримуваних типів під час виконання.

За замовчуванням ресурси звичайної фабрики завантажуються разом із нею. Щоб відкласти завантаження, увімкніть Load Dynamically, а потім асинхронно підготуйте ресурси за допомогою factory.load() або collectionfactory.load(). Вміст проксі колекції завантажується за вашим запитом.

Завантаження ресурсів із готового пакета під час гри й пізніше отримання ресурсів із мережі — різні завдання. Механізм Live Update дає змогу вилучити вміст із початкового пакета Defold і надати його окремо.

Докладніше читайте в посібнику з керування ресурсами.


Введення

Відповідником InputMap у Godot є файл .input_binding у Defold. Ви можете пов’язати сигнал від пристрою введення (клавіша, кнопка геймпада чи миші, дотик або текст) з іменованою дією. Файл прив’язок виберіть у Input ▸ Game Binding у налаштуваннях game.project.

Прив’язки введення

Щоб отримувати введення, ігровий об’єкт у Defold має отримати фокус введення. Після цього він потрапляє до стека введення, а його компоненти-скрипти та компоненти GUI можуть отримувати зворотні виклики on_input().

На знімку екрана клавішу Space прив’язано до дії collect. У наступному окремому прикладі використано дію fire, яку також потрібно додати до прив’язок введення:

GDScript:

extends Node

func _input(event):
    if event.is_action_pressed("fire"):
        print("Fire")

Lua:

function init(self)
    msg.post(".", "acquire_input_focus")
end

function on_input(self, action_id, action)
    if action_id == hash("fire") and action.pressed then
        print("Fire")
    end
end

Залежно від події таблиця action містить такі поля, як pressed, released і value.

Введення проходить через стек, починаючи зі слухача, який отримав фокус останнім. Поверніть true з on_input(), щоб зупинити подальше передавання дії, наприклад коли меню вже обробило клацання.

Коли світ завантажено через проксі, фокус введення мають отримати і об’єкт із проксі, і слухачі всередині цього світу. Якщо пропустити будь-який із цих кроків, скрипт, який працював раніше, може перестати отримувати введення після зміни рівня.

Докладніше читайте в посібнику про введення та в посібниках «Миша й дотик» і «Геймпади».


Фізика та колізії

Об’єкт колізій (Collision Object) у Defold відповідає фізичним тілам у Godot. Він поєднує в одному компоненті як налаштування фізики, так і форми колізій. У game.project можна вибрати 2D- або 3D-фізику. У маніфесті застосунку (App Manifest) можна додатково вибрати версію фізичного рушія або повністю вимкнути фізику.

Defold пропонує чотири типи об’єктів колізій:

Godot Тип у Defold Примітки
StaticBody2D / 3D Static Об’єкт не рухається. Динамічні об’єкти реагують на зіткнення з ним.
RigidBody2D / 3D Dynamic Фізичний рушій моделює рух і розв’язує колізії.
CharacterBody2D / 3D Kinematic Фізичний рушій надає дані про колізії, а реагувати на них і розв’язувати їх має ваш код.
Area2D Trigger Повідомляє лише про вхід і вихід, без фізичної реакції.

Кінематичний об’єкт у Defold поводиться інакше, ніж CharacterBody2D із методом move_and_slide(). Defold виявляє контакти й передає всі дані в повідомленні про колізію, а рух і реакцію на зіткнення визначає ваш скрипт. Створюючи контролер персонажа, зверніться до посібника з розв’язання колізій.

Для груп і масок використовують назви замість нумерованих шарів колізій. Щоб рушій зареєстрував зіткнення, маска кожного з двох об’єктів має містити групу іншого.

Групи й маски колізій у Defold

На знімку екрана ігровий об’єкт із назвою danger належить до групи player, а об’єкт із назвою player — до групи danger. Назви груп можуть відрізнятися від ідентифікаторів об’єктів. Налаштовані тут маски дають цим двом групам взаємодіяти.

За замовчуванням об’єкти колізій надсилають повідомлення скриптам на своїх ігрових об’єктах. Обробляйте "collision_response", "contact_point_response" та "trigger_response" у on_message(). Повідомлення тригера має поле enter, за яким можна відрізнити вхід від виходу. Повідомлення про колізію й точки контакту можуть надходити повторно, доки об’єкти торкаються один одного, тож кожне таке повідомлення не обов’язково означає новий удар.

Фізичні події можна також обробляти через слухач подій колізій. Виберіть один із підходів: слухач замінює стандартну доставку фізичних повідомлень, і після його встановлення рушій їх уже не надсилає.

Доступні різні примітивні та складні форми колізій. Докладніше читайте в посібнику про форми колізій.

Форма колізії на основі мешу

Додаткові відомості та відповідні API наведено в посібниках «Огляд фізики», «Об’єкти колізій», «Повідомлення про колізії» і «Трасування променів».


GUI

Інтерфейс користувача в Defold розміщується в компоненті GUI, створеному з файлу .gui. Усередині нього ви розташовуєте вузли GUI, наприклад прямокутники, текст і сектори. Компонентом GUI керує окремий скрипт .gui_script, подібно до скрипту, прикріпленого до CanvasLayer у Godot.

Ці вузли належать до GUI й не входять до ієрархії трансформацій ігрового об’єкта. За замовчуванням GUI відображається поверх гри й не переміщується разом з ігровою камерою чи об’єктом, що містить компонент GUI.

Призначте компоненту скрипт .gui_script, щоб керувати вузлами за допомогою gui.get_node(), gui.set_text() та інших функцій gui. API gui доступний лише у скриптах GUI, а API go — лише у скриптах ігрових об’єктів. Для зв’язку між ними використовуйте повідомлення, як у прикладі з рахунком вище.

Шаблони дають змогу повторно використовувати ієрархію вузлів іншого GUI, подібно до повторного використання вузла в Godot.

Для побудови інтерфейсу Defold надає прості вузли, а не готові віджети на зразок Button чи контейнерів компонування в Godot. Наприклад, щоб зробити кнопку, поєднайте прямокутник і текст, а у скрипті GUI додайте обробку введення. За допомогою gui.pick_node() перевіряйте, чи перебуває вказівник над кнопкою.

Інтерфейс Defold також підтримує шари (Layers), подібні до шарів CanvasLayer у Godot. Шари Defold мають назви замість чисел. Їхня послідовність у списку Layers визначає порядок малювання.

Якорі, опорні точки, режими адаптації та макети GUI допомагають пристосувати інтерфейс до різних екранів. Вони подібні до контейнерів компонування Godot, хоча працюють інакше.

Для більшого чи складнішого інтерфейсу можна написати власний код компонування й віджетів або скористатися бібліотекою спільноти, наприклад Druid.

Докладніше читайте в посібниках про GUI та скрипти GUI.

Анімація

Замість єдиного відповідника AnimationPlayer у Defold є кілька інструментів анімації:

  • Покадрова анімація відтворює послідовності зображень на спрайтах і прямокутних вузлах GUI.
  • Анімація моделей відтворює імпортовану скелетну анімацію на 3D-моделях.
  • Анімація властивостей інтерполює значення за допомогою go.animate() або gui.animate().
  • Spine, Rive і SpriteLoop — додаткові формати анімації, доступні через розширення.

Твіни й анімація властивостей Defold

Простий Tween у Godot легко відтворити анімацією властивості в Defold. Обидва приклади переміщують об’єкт до координати X = 200 за пів секунди:

GDScript, скрипт вузла Node2D:

func move_to_target():
    var tween = create_tween()
    tween.set_trans(Tween.TRANS_QUAD)
    tween.set_ease(Tween.EASE_OUT)
    tween.tween_property(self, "position:x", 200.0, 0.5)

Lua, скрипт ігрового об’єкта:

local function move_to_target()
    go.animate(".", "position.x", go.PLAYBACK_ONCE_FORWARD,
        200, go.EASING_OUTQUAD, 0.5)
end

Якщо послідовність змінює кілька властивостей, відтворює звуки чи запускає ігрові події, координуйте ці кроки в Lua. У Defold поки що немає спеціалізованого редактора шкали часу для анімацій. Вкладка Curve Editor на панелі Tools у Defold призначена для редагування кривих, за якими властивості ParticleFX змінюються впродовж життя частинки.

Див. посібники «Анімація», «Анімація властивостей», «Покадрова анімація» та «Анімація моделей». В оглядовому посібнику також є посилання на розширення Spine та Rive.

Карти плиток

Компонент Tilemap у Defold використовує джерело плиток, у якому плитки розміщено на сітці. У вбудованому редакторі карт плиток ви можете малювати плитками на різних шарах, а під час виконання — змінювати їх через API tilemap.

У вбудованих картах плиток Defold використовується прямокутна сітка. Набори місцевості та правила автоматичного розміщення плиток Godot поки що не можна перенести безпосередньо в Defold. Ви можете відтворити потрібну поведінку в коді або скористатися зовнішнім редактором карт з експортом у Defold, наприклад Tiled чи TileSetter.

Див. посібник про карти плиток.


Конвеєр рендерингу

У Defold є повністю керований скриптами конвеєр рендерингу: ви можете задати власний файл .render, скрипт .render_script і шейдери. Для більшості ігор підійде вбудований стандартний конвеєр.

Стандартний скрипт рендерингу Defold відображає звичайні 2D- і 3D-ресурси. Власний скрипт .render_script дає змогу керувати проходами малювання, цілями рендерингу та іншими операціями. За тегами матеріалів скрипт може відбирати групи компонентів за допомогою предикатів рендерингу. Defold має вбудовану підтримку фізично коректного рендерингу (PBR). Спільнота також створила багато власних конвеєрів рендерингу та шейдерів.

Defold використовує шейдери GLSL з окремими файлами для вершинної та фрагментної програм. Godot має власну подібну до GLSL мову зі специфічними для рушія вбудованими засобами. Тому шейдери з Godot або інших джерел, як-от Shadertoy, може знадобитися адаптувати. Вимоги Defold до шейдерів наведено в посібнику про шейдери.

Матеріали в Defold поєднують вершинну та фрагментну програми (шейдери), текстури, а також константи й атрибути шейдерів. У теці builtins є стандартні матеріали, які можна взяти за основу.

Коли знадобиться змінити стандартну поведінку, зверніться до посібників «Рендеринг», «Матеріали» та «Шейдери».

Порядок малювання та шари

Цілочисельна властивість z_index у Godot не має прямого відповідника в Defold. Зв’язок між координатою Z та глибиною зображення залежить від налаштувань рендерингу, тому переміщення вздовж осі Z не завжди означає зміну глибини. В основі Defold — тривимірний рушій. Він використовує справжню просторову координату Z, тоді як у Godot за сортування у 2D відповідає окремий цілочисельний індекс.

За стандартної ортографічної проєкції Defold малює лише об’єкти з координатою Z у межах від −1,0 до 1,0. Шари можна розташовувати, наприклад, на 0,1 чи 0,2, а діапазон можна змінити повідомленням до скрипту рендерингу. У межах цього діапазону стандартний конвеєр сортує за глибиною відповідно до координати Z ігрового об’єкта чи його компонента Sprite. Об’єкти з більшим Z відображаються поверх об’єктів із меншим Z, що нагадує z_index у Godot. Перемикання на перспективну камеру або зміни в .render_script можуть змінити цю поведінку.

Вузли GUI в Defold ігнорують світову координату Z: за замовчуванням компоненти GUI малюються окремим проходом після спрайтів ігрового світу. Тому зміна позиції Z вузла GUI не впливає на черговість його відображення. Порядок малювання визначає послідовність вузлів в ієрархії GUI (згори донизу на панелі Outline) та шари Layers. Шари мають пріоритет над порядком вузлів, що дає змогу групувати виклики малювання. Це дещо нагадує шари CanvasLayer.

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

Додайте компонент Camera до ігрового об’єкта. Щоб перемістити камеру, переміщуйте сам об’єкт. Для типового 2D-вигляду виберіть ортографічну проєкцію, для перспективного зображення в 3D — перспективну.

Стандартний скрипт рендерингу автоматично використовує камеру, яку ввімкнули останньою. Якщо в проєкті немає камер, за замовчуванням використовуватиметься ортографічний 2D-вигляд. Якщо є одна камера, використовуватиметься вона. Можна почати з цього налаштування, а згодом пристосувати рендеринг до потреб гри.

Камера змінює відповідність між координатами світу й екрана. Обробляючи дії вказівника в ігровому світі, перетворюйте його координати функціями API камери: екранні координати вказівника можуть відрізнятися від світових. Для визначення вузла GUI під вказівником за замовчуванням використовують координати GUI.

Про проєкцію, масштабування та перетворення координат читайте в посібнику про камеру.


Експорт гри

У Defold експорт називається пакуванням. Відкрийте Project ▸ Bundle, виберіть цільову платформу й налаштуйте параметри пакета. Редактор надає всі інструменти збирання, тож не потрібно окремо встановлювати нічого подібного до шаблонів експорту Godot.

У файлі game.project зберігаються налаштування проєкту та платформ, зокрема головна колекція, прив’язки введення й розмір екрана. Вимоги платформ до підписування та правила магазинів можуть надалі застосовуватися. Для проєктів із нативними розширеннями потрібне мережеве з’єднання, щоб зібрати власну версію рушія у хмарному сервісі збирання. За потреби можна самостійно налаштувати й локальне збирання.

Остаточний розмір пакета залежить від ресурсів, розширень і налаштувань збирання. Згенеруйте звіт Build Report, щоб побачити, що саме потрапило до гри.

Див. посібники «Пакування», «Налаштування проєкту» та «HTML5». Перевірте пакет на цільовій платформі ще на початку розробки, особливо якщо гра використовує шейдери, нативні розширення чи платформні сервіси.

Бібліотеки та розширення

До проєктів Defold можна додавати бібліотечні залежності (Library Dependencies) зі спільними скриптами та ресурсами. Додайте URL-адреси їхніх архівів у game.project та завантажте бібліотеки. Радимо шукати їх на Defold Asset Portal. Також є розширення редактора Asset Store, за допомогою якого можна, як у Godot, шукати й завантажувати ресурси прямо в редакторі Defold.

Скрипти редактора та засоби створення інтерфейсу дають змогу додавати команди, автоматизувати завдання й створювати власні елементи інтерфейсу редактора. Наприклад, можна пришвидшити редагування рівнів, створення ресурсів або автоматичне розміщення плиток. Ці засоби розв’язують частину тих самих завдань, що й EditorPlugin та @tool у Godot, але використовують власний API editor та життєвий цикл Defold.

Коли можливостей Lua недостатньо, нативні розширення дають змогу викликати нативний код зі скриптів, додавати компоненти та інтегрувати платформні сервіси. Їхня роль подібна до GDExtension, але API та процес збирання відрізняються.

Див. посібники «Бібліотеки», «Скрипти редактора» та «Нативні розширення».

Гаряче перезавантаження

У Defold можна оновлювати ресурси в запущеній грі. Зберіть і запустіть гру, відредагуйте ресурс із підтримкою гарячого перезавантаження, збережіть його й виберіть File ▸ Hot Reload. Гаряче перезавантаження також працює, якщо цільовою для редактора вибрано налагоджувальну збірку, запущену на пристрої.

Перезавантаження скрипту не викликає init() повторно. Наявні дані екземпляра зберігаються, тому нове початкове значення не з’явиться в self автоматично. За потреби змініть поточний стан у on_reload(self) або зберіть гру заново, щоб почати з початкового стану. Якщо модуль Lua після перезавантаження повертає нову таблицю, в інших скриптах залишаються посилання на стару. Докладніше читайте в посібнику про модулі.

Див. посібник про гаряче перезавантаження.

Точки зупину та налагодження

Вбудований налагоджувач редактора дає змогу встановлювати точки зупину, виконувати код покроково та перевіряти значення. Виведення запущеної гри переглядайте у вкладці Console, а помилки збирання — у Build Errors. Профайлер допомагає дослідити тривалість кадру, використання пам’яті та рендеринг. Звіти про збирання показують, які ресурси впливають на розмір пакета.

Див. посібники «Налагодження ігрової логіки» та «Профілювання».

Автоматизовані робочі процеси

Defold надає кілька інтерфейсів для автоматизації та розробки за допомогою ШІ. Скрипти редактора автоматизують повторювані завдання, а HTTP API редактора, описаний у форматі OpenAPI, дає зовнішнім інструментам і ШІ-агентам змогу інспектувати проєкти, виконувати команди й запускати збирання. HTTP-сервіс рушія та розширення Automation Bridge дають змогу інспектувати гру під час виконання, імітувати введення й робити знімки екрана. Разом ці засоби дають ШІ-агентам для програмування, зокрема Codex, Claude Code і Cursor, змогу змінювати проєкти, збирати ігри, перевіряти поведінку та виправляти проблеми за кілька послідовних циклів.

Докладніше читайте в посібниках «Автоматизація», «HTTP API редактора», «Сервіс рушія» та «Автоматизоване тестування».


Поширені помилки

Сприймати колекцію як кореневий вузол

Колекція Defold описує ігрові об’єкти та їхні зв’язки, але під час виконання не стає кореневим об’єктом. Щоб координувати об’єкти рівня, додайте ігровий об’єкт із власним скриптом. Див. «Колекції та світи».

Видаляти лише кореневий об’єкт ієрархії

У Godot функція queue_free() видаляє також усіх нащадків вузла. У Defold після go.delete(id) дочірні ігрові об’єкти залишаються, якщо ви явно не ввімкнули рекурсивне видалення. Приклад і спосіб видалення об’єктів, створених фабрикою колекції, наведено в розділі «Фабрики».

Розраховувати на успадкування сцен

У Defold немає такого механізму успадкування сцен, як у Godot, тому вільно перевизначати структуру похідної сцени в такий самий спосіб не вийде. Ви можете повторно використовувати прототипи й колекції та налаштовувати екземпляри через властивості або скрипти. Див. «Колекції та світи».

Викликати інший скрипт через посилання на об’єкт

Ідентифікатор ігрового об’єкта Defold не дає довільного доступу до функцій іншого екземпляра скрипту. Для зв’язку між компонентами використовуйте повідомлення, а спільні функції можна винести в модуль Lua. Див. «Повідомлення та адресація» та «Автозавантаження та спільний стан».

Зберігати стан екземпляра в локальній змінній верхнього рівня

Локальна змінна верхнього рівня у файлі скрипту спільна для всіх екземплярів, які використовують цей файл. Зміна для одного екземпляра може позначитися на інших. Зберігайте стан окремого екземпляра в self, як описано в розділі «Дані екземпляра й локальні дані».

Припускати, що введення ввімкнено автоматично

Ігровий об’єкт Defold має отримати фокус введення, перш ніж його компоненти зможуть отримувати введення. Якщо світ завантажено через проксі, об’єкт із цим проксі теж має отримати фокус. Про прив’язки, фокус і роботу стека введення читайте в розділі «Введення».

Очікувати автоматичного ковзання від кінематичного об’єкта колізій

Defold виявляє контакти кінематичних об’єктів колізій, але автоматично не відтворює поведінку move_and_slide() з Godot. Ваш скрипт має керувати рухом і реакцією на колізії. Див. «Фізика та колізії».

Налаштувати маску колізій лише для одного об’єкта

Рушій не зареєструє зіткнення, якщо лише один об’єкт налаштовано на взаємодію з іншим. Маска кожного з двох об’єктів має містити групу іншого. Див. «Фізика та колізії».

Копіювати 2D-координати без змін

У Godot і в типовій 2D-грі Defold вісь Y спрямовано в протилежні боки, тому після перенесення коду руху об’єкт може рушити в протилежний бік. Коли використовується камера, екранні та світові координати теж відрізняються. Див. «Координати» та «Камери та координати».

Сортувати вузли GUI за світовою координатою Z

Зміна координати Z вузла GUI у Defold не керує порядком його малювання. Натомість використовуйте порядок вузлів і шари GUI, як описано в розділі «Порядок малювання та шари».

Очікувати повторного запуску об’єкта після гарячого перезавантаження

Гаряче перезавантаження скрипту не викликає init() повторно, тому попередні значення стану екземпляра можуть зберегтися. Про роботу зі станом і перезавантаженням модулів читайте в розділі «Гаряче перезавантаження».

Очікувати скидання спільного стану під час вивантаження рівня

Стан Autoload у Godot та кешований стан модулів Lua можуть зберігатися між рівнями, тому за потреби явно скидайте спільні дані. На відміну від вузла Autoload, модуль Lua не отримує зворотних викликів автоматично. Див. «Автозавантаження та спільний стан».

Що далі?

На навчальному порталі Defold зібрано посібники, приклади, уроки, відео, курси та інші матеріали, які допоможуть почати роботу й глибше розібратися в Defold. Радимо ознайомитися з такими матеріалами:

Якщо виникнуть труднощі, зверніться на форум Defold або в Discord. Іншим буде простіше допомогти, якщо ви покажете невеликий проєкт і опишете, яку поведінку Godot хочете відтворити.