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

Types de composants

Defold prend en charge les types de composant (component) suivants :

• Factory de collection - Créer des collections
• Proxy de collection (collection proxy) - Charger et décharger des collections
• Objet de collision - Physique 2D et 3D
• Caméra - Modifier la fenêtre d’affichage et la projection du monde de jeu (game world)
• Factory - Créer des objets de jeu (game object)
• GUI - Effectuer le rendu d’une interface graphique
• Étiquette - Afficher un texte
• Lumière - Ajouter des données d’éclairage pour les shaders
• Maillage Afficher un maillage 3D (avec création et manipulation à l’exécution)
• Modèle Afficher un modèle 3D (avec des animations facultatives)
• Effets de particules - Créer des particules
• Script - Ajouter la logique du jeu
• Son - Jouer du son ou de la musique
• Sprite - Afficher une image 2D (avec une animation image par image facultative)
• Tilemap - Afficher une grille de tuiles

Des composants supplémentaires peuvent être ajoutés au moyen d’extensions :

• Modèle Rive - Effectuer le rendu d’une animation Rive
• Modèle Spine - Effectuer le rendu d’une animation Spine

Activation et désactivation des composants

Les composants d’un objet de jeu sont activés lors de la création de cet objet de jeu. Si vous souhaitez désactiver un composant, envoyez-lui un message disable :

-- disable the component with id 'weapon' on the same game object as this script
msg.post("#weapon", "disable")

-- disable the component with id 'shield' on the 'enemy' game object
msg.post("enemy#shield", "disable")

-- disable all components on the current game object
msg.post(".", "disable")

-- disable all components on the 'enemy' game object
msg.post("enemy", "disable")

Pour réactiver un composant, vous pouvez lui envoyer un message enable :

-- enable the component with id 'weapon'
msg.post("#weapon", "enable")

Propriétés des composants

Chaque type de composant Defold possède des propriétés différentes. Le panneau Properties de l’éditeur affiche les propriétés du composant actuellement sélectionné dans le panneau Outline. Consultez les manuels des différents types de composants pour en savoir plus sur les propriétés disponibles.

Position, rotation et échelle des composants

Les composants visuels possèdent généralement des propriétés de position et de rotation, et le plus souvent aussi une propriété d’échelle. Ces propriétés peuvent être modifiées depuis l’éditeur et, dans presque tous les cas, elles ne peuvent pas être modifiées à l’exécution (la seule exception est l’échelle des composants sprite et label, qui peut être modifiée à l’exécution).

Si vous avez besoin de modifier la position, la rotation ou l’échelle d’un composant à l’exécution, vous devez modifier la position, la rotation ou l’échelle de l’objet de jeu auquel il appartient. Cela a pour effet d’affecter tous les composants de cet objet de jeu. Si vous souhaitez manipuler un seul composant parmi les nombreux composants attachés à un objet de jeu, il est recommandé de déplacer le composant en question vers un objet de jeu distinct, puis d’ajouter ce dernier comme enfant de l’objet de jeu auquel le composant appartenait à l’origine.

Ordre de rendu des composants

L’ordre de rendu des composants visuels dépend de deux éléments :

Prédicats du script de rendu

Chaque composant se voit attribuer un matériau, et chaque matériau possède une ou plusieurs étiquettes. Le script de rendu définit à son tour un certain nombre de prédicats, chacun correspondant à une ou plusieurs étiquettes de matériau. Les prédicats du script de rendu sont dessinés un par un dans la fonction update() du script de rendu, et les composants correspondant aux étiquettes définies dans chaque prédicat sont dessinés. Le script de rendu par défaut dessine d’abord les sprites et les tilemaps en une passe, puis les effets de particules en une autre passe, toutes deux dans l’espace du monde. Le script de rendu dessine ensuite les composants GUI en une passe distincte dans l’espace de l’écran.

Valeur Z du composant

Tous les objets de jeu et tous les composants sont positionnés dans un espace 3D, avec des positions exprimées sous forme d’objets vector3. Lorsque vous visualisez le contenu graphique de votre jeu en 2D, les valeurs X et Y déterminent la position d’un objet le long des axes de « largeur » et de « hauteur », tandis que la position Z détermine sa position le long de l’axe de « profondeur ». La position Z vous permet de contrôler la visibilité des objets qui se chevauchent : un sprite dont la valeur Z est 1 apparaît devant un sprite dont la position Z est 0. Par défaut, Defold utilise un système de coordonnées qui autorise des valeurs Z comprises entre -1 et 1 :

Les composants correspondant à un prédicat de rendu sont dessinés ensemble, et l’ordre dans lequel ils sont dessinés dépend de la valeur Z finale du composant. La valeur Z finale d’un composant est la somme des valeurs Z du composant lui-même, de l’objet de jeu auquel il appartient et de tous les objets de jeu parents.

Exemple : deux objets de jeu A et B. B est un enfant de A. B possède un composant sprite.

Avec la hiérarchie ci-dessus, la valeur Z finale du composant sprite de B est 2 + 1 + 0.5 = 3.5.

Optimisation du nombre maximal de composants

Le fichier de paramètres game.project contient de nombreuses valeurs qui définissent le nombre maximal d’instances d’une ressource donnée pouvant exister simultanément, souvent comptabilisées par collection chargée (également appelée monde de jeu, ou game world). Le moteur Defold utilise ces valeurs maximales pour préallouer la mémoire correspondante, afin d’éviter les allocations dynamiques et la fragmentation de la mémoire pendant l’exécution du jeu.

Les structures de données de Defold utilisées pour représenter les composants (components) et les autres ressources sont optimisées pour occuper aussi peu de mémoire que possible, mais il faut tout de même choisir ces valeurs avec soin pour éviter d’allouer plus de mémoire que nécessaire.

Pour optimiser davantage l’utilisation de la mémoire, le processus de build de Defold analyse le contenu du jeu et remplace les nombres maximaux lorsqu’il est possible de déterminer avec certitude le nombre exact d’instances :

• Si une collection ne contient aucun composant factory, le nombre exact d’instances de chaque composant et d’objet de jeu (game object) est alloué, et les valeurs maximales sont ignorées.
• Si une collection contient un composant factory, les objets créés sont analysés et le nombre maximal est utilisé pour les composants pouvant être créés par les factory ainsi que pour les objets de jeu.
• Si une collection contient un composant factory ou collection factory avec l’option “Dynamic Prototype” activée, cette collection utilise les valeurs maximales.