Éléments constitutifs

La conception de Defold repose sur quelques concepts qu’il est essentiel de bien comprendre. Ce manuel présente les éléments constitutifs de Defold. Après l’avoir lu, poursuivez avec le manuel sur l’adressage et le manuel sur l’échange de messages. Un ensemble de tutoriels est également accessible depuis l’éditeur pour vous aider à démarrer rapidement.

Vous utilisez trois types d’éléments de base pour construire un jeu Defold :

Collection

Une collection est un fichier qui sert à structurer votre jeu. Dans les collections, vous construisez des hiérarchies d’objets de jeu et d’autres collections. Elles servent généralement à structurer les niveaux du jeu, les groupes d’ennemis ou les personnages composés de plusieurs objets de jeu.

Objet de jeu (game object)

Un objet de jeu est un conteneur doté d’un identifiant, d’une position, d’une rotation et d’une échelle. Il sert à contenir des composants. Les objets de jeu servent généralement à créer les personnages jouables, les projectiles, le système de règles du jeu ou un chargeur de niveaux.

Composant (component)

Les composants sont des entités placées dans des objets de jeu pour leur donner une représentation visuelle, sonore et/ou logique dans le jeu. Ils servent généralement à créer les sprites des personnages, les fichiers de script, à ajouter des effets sonores ou des effets de particules.

Collections

Les collections sont des structures arborescentes qui contiennent des objets de jeu et d’autres collections. Une collection est toujours stockée dans un fichier.

Lorsque le moteur Defold démarre, il charge une seule collection bootstrap, définie dans le fichier de paramètres game.project. La collection bootstrap est souvent nommée “main.collection”, mais vous êtes libre de choisir le nom que vous voulez.

Une collection peut contenir des objets de jeu et d’autres collections (par référence au fichier de la sous-collection), imbriqués à n’importe quelle profondeur. Voici un exemple de fichier nommé “main.collection”. Il contient un objet de jeu (avec l’identifiant “can”) et une sous-collection (avec l’identifiant “bean”). Cette sous-collection contient à son tour deux objets de jeu : “bean” et “shield”.

Notez que la sous-collection dont l’identifiant est “bean” est stockée dans son propre fichier, nommé “/main/bean.collection”, et que “main.collection” ne contient qu’une référence à ce fichier :

Vous ne pouvez pas adresser les collections elles-mêmes, car aucun objet ne correspond aux collections “main” et “bean” à l’exécution. Vous devez toutefois parfois utiliser l’identité d’une collection dans le chemin vers un objet de jeu (consultez le manuel sur l’adressage pour plus de détails) :

-- file: can.script
-- get position of the "bean" game object in the "bean" collection
local pos = go.get_position("bean/bean")

Une collection est toujours ajoutée à une autre collection sous la forme d’une référence à un fichier de collection :

Faites un clic droit sur la collection dans la vue Outline et sélectionnez Add Collection File.

Objets de jeu

Les objets de jeu sont des objets simples qui ont chacun leur propre durée de vie pendant l’exécution de votre jeu. Ils possèdent une position, une rotation et une échelle qui peuvent chacune être modifiées et animées à l’exécution.

-- animate X position of "can" game object
go.animate("can", "position.x", go.PLAYBACK_LOOP_PINGPONG, 100, go.EASING_LINEAR, 1.0)

Les objets de jeu peuvent être utilisés vides (comme repères de position, par exemple), mais ils sont généralement dotés de divers composants, tels que des sprites, des sons, des scripts, des modèles, des factories et d’autres encore. Les objets de jeu sont soit créés dans l’éditeur et placés dans des fichiers de collection, soit générés dynamiquement à l’exécution au moyen de composants factory.

Les objets de jeu sont soit ajoutés directement dans une collection, soit ajoutés à une collection sous la forme d’une référence à un fichier d’objet de jeu :

Faites un clic droit sur la collection dans la vue Outline et sélectionnez Add Game Object (ajout direct) ou Add Game Object File (ajout par référence à un fichier).

Composants

Les composants (components) servent à donner une apparence et/ou des fonctionnalités spécifiques aux objets de jeu (game objects). Les composants doivent être contenus dans des objets de jeu et sont affectés par la position, la rotation et l’échelle de l’objet de jeu qui les contient :

De nombreux composants possèdent des propriétés propres à leur type qui peuvent être manipulées, et des fonctions propres à chaque type de composant permettent d’interagir avec eux à l’exécution :

-- disable the can "body" sprite
msg.post("can#body", "disable")

-- play "hoohoo" sound on "bean" in 1 second
sound.play("bean#hoohoo", { delay = 1, gain = 0.5 } )

Les composants sont ajoutés soit directement dans un objet de jeu, soit sous forme de référence à un fichier de composant :

Faites un clic droit sur l’objet de jeu dans la vue Outline et sélectionnez Add Component (ajout direct) ou Add Component File (ajout par référence à un fichier).

Dans la plupart des cas, il est préférable de créer les composants directement dans l’objet de jeu, mais les types de composants suivants doivent être créés dans des fichiers de ressources distincts avant d’être ajoutés par référence à un objet de jeu :

• Script
• GUI
• Particle FX
• Tile Map

Consultez la présentation des composants pour obtenir la liste de tous les types de composants disponibles.

Objets ajoutés directement ou par référence

Lorsque vous créez un fichier de collection, d’objet de jeu ou de composant, vous créez ce que nous appelons un prototype (également appelé « prefab » ou « blueprint » dans d’autres moteurs). Cela ajoute seulement un fichier à l’arborescence du projet ; rien n’est ajouté à votre jeu en cours d’exécution. Pour ajouter une instance de collection, d’objet de jeu ou de composant fondée sur un fichier prototype, vous en ajoutez une instance dans l’un de vos fichiers de collection.

Vous pouvez voir sur quel fichier repose une instance d’objet dans la vue Outline. Le fichier “main.collection” contient trois instances fondées sur des fichiers :

1. La sous-collection “bean”.
2. Le composant script “bean” de l’objet de jeu “bean” dans la sous-collection “bean”.
3. Le composant script “can” de l’objet de jeu “can”.

L’intérêt de créer des fichiers prototypes devient évident lorsque vous avez plusieurs instances d’un objet de jeu ou d’une collection et souhaitez toutes les modifier :

Lorsque vous modifiez le fichier prototype, toute instance qui utilise ce fichier est immédiatement mise à jour.

Ici, l’image du sprite du fichier prototype est modifiée, et toutes les instances qui utilisent ce fichier sont immédiatement mises à jour :

Relations parent-enfant entre objets de jeu

Dans un fichier de collection, vous pouvez construire des hiérarchies d’objets de jeu dans lesquelles un ou plusieurs objets de jeu sont les enfants d’un même objet de jeu parent. Il suffit de faire glisser un objet de jeu et de le déposer sur un autre pour que l’objet déplacé devienne un enfant de l’objet cible :

Les hiérarchies parent-enfant entre objets constituent une relation dynamique qui détermine la manière dont les objets réagissent aux transformations. Toute transformation (déplacement, rotation ou mise à l’échelle) appliquée à un objet est à son tour appliquée aux enfants de cet objet, aussi bien dans l’éditeur qu’à l’exécution :

Inversement, les translations d’un enfant s’effectuent dans l’espace local du parent. Dans l’éditeur, vous pouvez choisir de modifier un objet de jeu enfant dans l’espace local ou dans l’espace du monde en sélectionnant Edit ▸ World Space (par défaut) ou Edit ▸ Local Space.

Il est également possible de changer le parent d’un objet à l’exécution en envoyant un message set_parent à cet objet.

local parent = go.get_id("bean")
msg.post("child_bean", "set_parent", { parent_id = parent })