De Unity à Godot Engine

Ce guide fournit un aperçu de Godot Engine d’un point de vue d’un utilisateur de Unity, et vise à vous aider à transiter de votre expérience de Unity vers le monde de Godot.

Différences

  Unity Godot
Licence Propriétaire, fermé, licence gratuite avec une limite de revenus et des restrictions d’usage Licence MIT, libre et open source sans aucune restriction
OS (éditeur) Windows, macOS, Linux (non-official and non-supported) Windows, macOS, X11 (Linux, *BSD)
OS (export)
  • Bureau : Windows, macOS, Linux
  • Mobile : Android, iOS, Windows Phone, Tizen
  • Web : WebAssembly or asm.js
  • Consoles : PS4, PS Vita, Xbox One, Xbox 360, Wii U, Nintendo 3DS
  • VR : Oculus Rift, SteamVR, Google Cardboard, Playstation VR, Gear VR, HoloLens
  • TV : Android TV, Samsung SMART TV, tvOS
Système de scène
  • Composant/Scène (GameObject > Composant)
  • Prefabs
Un arbre de scènes et des nœuds, permettant aux scènes d’être imbriquées ou d’hériter d’autres scènes
Outils de tierce partie Visual Studio ou VS Code
Fonctionnalités de tueurs
  • Immense communauté
  • Grande boutique en ligne de ressources

L’éditeur

Godot Engine propose un éditeur richement fourni vous permettant de construire vos jeux. Les images ci-dessous affichent les deux éditeurs avec des blocs de couleur pour indiquer les fonctionnalités communes.

../../_images/unity-gui-overlay.png ../../_images/godot-gui-overlay.png

Notez que l’éditeur Godot vous permet d’accrocher chaque panneau sur le côté souhaité de l’éditeur de scène.

Bien que les deux éditeurs puissent sembler similaires, il existe de nombreuses différences sous la surface. Les deux vous permettent d’organiser le projet en utilisant le système de fichiers, mais l’approche de Godot est plus simple avec un seul fichier de configuration, format de texte minimaliste, et pas de métadonnées. Tout cela contribue à rendre Godot plus convivial avec les systèmes VCS tels que Git, Subversion ou Mercurial.

Le panneau Scène de Godot est similaire au panneau Hiérarchie d’Unity, mais comme chaque nœud a une fonction spécifique, l’approche utilisée par Godot est plus parlante visuellement. En d’autres termes, il est plus facile de comprendre ce que fait une scène spécifique d’un coup d’œil.

L’inspecteur dans Godot est plus minimaliste et conçu pour afficher uniquement les propriétés. Grâce à cela, les objets peuvent exporter une quantité beaucoup plus importante de paramètres utiles sans avoir à cacher des fonctionnalités dans les API de langage. De plus, Godot permet d’animer visuellement toutes ces propriétés. Il est donc possible de changer les couleurs, les textures, les énumérations ou même les liens vers les ressources en temps réel sans nécessiter de code.

Enfin, la barre d’outils en haut de l’écran est similaire dans le sens où elle permet de contrôler la lecture du projet, mais dans Godot, les projets sont exécutés dans une fenêtre séparée car ils ne s’exécutent pas dans l’éditeur (toutefois l’arborescence et les objets sont toujours visibles dans la fenêtre du débogueur).

Cette approche a l’inconvénient que le jeu en cours ne peut pas être vu sous différents angles (bien que cela puisse être supporté à l’avenir et que l’affichage des gadgets de collision dans le jeu en cours soit déjà possible), mais en échange a plusieurs avantages :

  • Lancer le projet et le fermer est rapide (Unity doit sauvegarder, exécuter le projet, fermer le projet, puis recharger l’état précédent).
  • Le montage en direct est beaucoup plus pratique car les modifications apportées par l’éditeur prennent effet immédiatement dans le jeu et ne sont pas perdues (ni n’ont besoin d’être synchronisées) lorsque le jeu est fermé. Cela permet des flux de travail fantastiques, comme la création de niveaux pendant que vous les jouez.
  • L’éditeur est plus stable car le jeu s’exécute dans un processus distinct.

Enfin, la barre d’outils supérieure comprend un menu pour le débogage à distance. Ces options facilitent le déploiement sur un périphérique (téléphone connecté, tablette ou navigateur via HTML5) ainsi que le débogage / modification en direct après l’exportation du jeu.

Le système de scène

C’est la différence la plus importante entre Unity et Godot et, en fait, la caractéristique préférée de la plupart des utilisateurs de Godot.

Le système de scène d’Unity consiste à intégrer tous les actifs requis dans une scène et à les relier ensemble en leur attribuant des composants et des scripts.

Le système de scène de Godot est différent : il s’agit en fait d’un arbre constitué de nœuds. Chaque nœud a un but : Sprite, Mesh, Light, etc. Fondamentalement, cela est similaire au système de scène Unity. Cependant, chaque nœud peut avoir plusieurs enfants, ce qui fait de chacun d’eux une scène dans à la scène principale. Cela signifie que vous pouvez composer une scène entière avec différentes scènes stockées dans des fichiers différents.

Par exemple, pensez à un niveau de plateforme. Vous le composeriez avec plusieurs éléments :

  • Les briques
  • Les pièces
  • Le joueur
  • Les ennemis

Dans Unity, vous placeriez tous les GameObjects dans la scène : le joueur, plusieurs instances d’ennemis, des briques partout pour former le sol, puis plusieurs instances de pièces sur tout le niveau. Vous ajouteriez alors différents composants à chaque élément pour les lier et ajouter de la logique au niveau : Par exemple, vous ajouteriez un BoxCollider2D à tous les éléments de la scène pour qu’ils puissent entrer en collision. Ce principe est différent dans Godot.

Dans Godot, vous diviseriez toute votre scène en 3 scènes plus petites et distinctes, que vous placeriez ensuite dans la scène principale.

  1. Tout d’abord, une scène pour le joueur seul.

Considérez le joueur comme un élément réutilisable dans d’autres niveaux. Il est composé d’un nœud en particulier : un nœud AnimatedSprite, qui contient les textures du sprite pour former diverses animations (par exemple, animation de marche)

  1. Deuxièmement, une scène pour l’ennemi.

Là encore, un ennemi est un élément réutilisable à d’autres niveaux. C’est presque le même que le nœud du joueur - les seules différences sont le script (qui gère principalement l’IA) et les textures de sprites utilisées par AnimatedSprite.

  1. Enfin, la scène niveau.

Il est composé de briques (pour les plates-formes), de pièces (à attraper par le joueur) et d’un certain nombre d’instances de la scène ennemi précédente. Ceux-ci seront différents, des ennemis distincts, dont le comportement et l’apparence seront les mêmes que ceux définis dans la scène ennemi. Chaque instance est alors considérée comme un nœud dans l’arborescence de la scène niveau. Bien entendu, vous pouvez définir différentes propriétés pour chaque nœud ennemi (pour changer sa couleur, par exemple).

Enfin, la scène principale serait alors composée d’un nœud racine avec 2 enfants : un nœud d’instance joueur et un nœud d’instance niveau. Le nœud racine peut être n’importe quoi, généralement un type « racine » tel que « Node » qui est le type le plus courant, ou « Node2D » (type racine de tous les nœuds liés à la 2D), « Spatial » (type racine de tous les nœuds associés à la 3D) ou « Control » (type racine de tous les nœuds liés à l’interface graphique).

Comme vous pouvez le voir, chaque scène est organisée en arborescence. Il en va de même pour les propriétés des nœuds : vous n’ajoutez pas un composant de collision à un nœud pour le rendre réactif aux collisions, contrairement à Unity. Au lieu de cela, vous faites de ce nœud un enfant d’un nouveau nœud spécifique possédant des propriétés de collision. Godot propose différents types de nœuds de collision, en fonction de l’utilisation (voir: ref: Introduction à la physique <doc_physics_introduction>).

  • Question : Quels sont les avantages de ce système? Ce système ne pourrait-il pas augmenter la profondeur de l’arborescence de la scène ? De plus, Unity permet d’organiser les GameObjects en les mettant dans des GameObjects vides.

    • Premièrement, ce système est plus proche du paradigme bien connu orienté objet : Godot fournit un certain nombre de nœuds qui ne sont pas clairement des « objets de jeu », mais ils fournissent à leurs enfants leurs propres capacités: c’est l’héritage.
    • Deuxièmement, il permet d’extraire une sous-arborescence de scène pour en faire une scène à part entière, qui répond aux deuxième et troisième questions : même si une arborescence de scène devient trop profond, elle peut être divisée en sous-arborescences plus petites. Cela permet également une meilleure solution de réutilisation, car vous pouvez inclure n’importe quel sous-arborescences en tant qu’enfant de n’importe quel nœud. Mettre plusieurs nœuds dans un GameObject vide dans Unity n’offre pas la même possibilité, hormis une organisation visuelle.

Ce sont les concepts les plus importants dont vous devez vous souvenir : « nœud », « nœud parent » et « nœud enfant ».

Organisation du projet

../../_images/unity-project-organization-example.png

Nous avons précédemment observé qu’il n’y a pas de solution parfaite pour définir une architecture de projet. Toute solution fonctionnera pour Unity et Godot, alors ce point a moins d’importance.

Cependant, nous observons souvent une architecture commune pour les projets Unity, qui consiste à avoir un dossier Assets dans le répertoire racine qui contient différents dossiers, un par type d’actif : Audio, Graphiques, Modèles, Matériaux, Scripts, Scènes, etc.

Comme décrit précédemment, le système de scène de Godot permet de diviser des scènes en scènes plus petites. Comme chaque scène et sous-scène est en fait un fichier de scène dans le projet, nous vous recommandons d’organiser votre projet un peu différemment. Ce wiki fournit une page pour ceci : Organisation du projet.

Où sont mes prefabs (préfabriqués) ?

Le concept de préfabriqué (prefab) fourni par Unity est un élément «modèle» de la scène. Il est réutilisable et chaque instance du préfabriqué existant dans la scène a une existence propre, mais toutes ont les mêmes propriétés que celles définies par le préfabriqué.

Godot ne fournit pas de préfabriqué en tant que tel, mais cette fonctionnalité est là encore remplie grâce à son système de scène : Comme nous avons vu le système de scène est organisé comme un arbre. Godot vous permet de sauvegarder un sous-arbre d’une scène en tant que sa propre scène, donc enregistré dans son propre fichier. Cette nouvelle scène peut alors être instanciée autant de fois que vous le souhaitez. Tout changement que vous apporterez à cette nouvelle scène séparée sera appliqué à ses instances. Cependant, toute modification apportée à l’instance n’aura aucun impact sur la scène “modèle”.

../../_images/save-branch-as-scene.png

Pour être précis, vous pouvez modifier les paramètres de l’instance dans le panneau Inspecteur. Toutefois, les nœuds qui composent cette instance sont verrouillés, mais vous pouvez les déverrouiller en cliquant avec le bouton droit de la souris sur l’instance dans l’arborescence de la scène et en sélectionnant « Enfants modifiables » dans le menu. Vous n’avez pas besoin de faire cela pour ajouter de nouveaux nœuds enfants à ce nœud, mais c’est possible. Rappelez-vous que ces nouveaux enfants appartiendront à l’instance, pas à la scène “template”. Si vous souhaitez ajouter de nouveaux enfants à toutes les instances de votre scène “template”, vous devez les ajouter dans la scène “template”.

../../_images/editable-children.png

Correspondance de glossaire

  • GameObject -> Node
  • Ajouter un composant -> Hériter
  • Préfab -> Branche externalisée

Scripting: GDScript, C# et Visual Script

Conception

Comme vous le savez peut-être déjà, Unity prend en charge le C#. Le C# bénéficie de son intégration à Visual Studio et d’autres fonctionnalités, telle que la saisie statique.

Godot fournit son propre langage de script, GDScript ainsi que le support pour Visual Script et C#. GDScript emprunte sa syntaxe à Python, mais n’y est pas lié. Si vous vous interrogez sur la raison d’un langage de script personnalisé, lisez les pages GDScript basics et Foire aux questions. GDScript est fortement attaché à l’API Godot et est très facile à apprendre : entre une soirée pour un programmeur expérimenté et une semaine pour un pure débutant.

Unity vous permet d’attacher autant de scripts que vous voulez à un GameObject. Chaque script ajoute un comportement au GameObject : Par exemple, vous pouvez attacher un script pour qu’il réagisse aux commandes du joueur, et un autre qui contrôle sa logique de jeu spécifique.

Dans Godot, vous ne pouvez joindre qu’un seul script par nœud. Vous pouvez utiliser un fichier GDScript externe ou inclure le script directement dans le nœud. Si vous avez besoin d’attacher plus de scripts à un nœud, vous pouvez envisager deux solutions en fonction de votre scène et de ce que vous souhaitez réaliser :

  • soit ajouter un nouveau nœud entre votre nœud cible et son parent actuel, puis ajouter un script à ce nouveau nœud.
  • ou, vous pouvez diviser votre nœud cible en plusieurs enfants et joindre un script à chacun d’eux.

Comme vous pouvez le voir, il peut être facile de transformer une arborescence de scène en désordre. C’est pourquoi il est important d’avoir une réelle réflexion et d’envisager de scinder une scène compliquée en plusieurs branches plus petites.

Connexions : groupes et signaux

Vous pouvez contrôler les nœuds en y accédant à l’aide de scripts et de fonctions d’appel (intégrées ou définies par l’utilisateur). Vous pouvez également les placer dans un groupe et appeler une fonction sur tous les nœuds contenus dans ce groupe! Ceci est expliqué dans :ref: cette page <doc_scripting_continued>.

Certains nœuds peuvent émettre des signaux lorsque certaines actions se produisent. Vous pouvez connecter ces signaux pour appeler une fonction spécifique lorsqu’ils se produisent. Notez que vous pouvez définir vos propres signaux et les envoyer quand vous le souhaitez. Cette fonctionnalité est documentée ici.

Sérialisation de scripts

Unity peut gérer la sérialisation de scripts de deux manières :

  • Implicite : Tous les champs publics de la classe sont automatiquement sérialisés si le type est sérialisable (Dictionary n’est pas sérialisable).
  • Explicite: Les champs non-publics peuvent être sérialisés en utilisant l’attribut [SerializeField].

Godot a également un système intégré de sérialisation de scripts, mais il ne fonctionne qu’explicitement. Vous pouvez sérialiser n’importe quel type sérialisable (intégrés et de nombreux types du moteur, y compris Array et Dictionary) en utilisant le mot-clé export. Ce fonctionnement est expliqué ici.

Unity possède également un type de données appelé ScriptableObject utilisé pour sérialiser les objets ressources personnalisés. Son équivalent dans Godot est la classe de base pour toutes les ressources : ref:class_Resource”. Créer un script qui hérite de :ref:`class_Resource vous permettra de créer des objets sérialisables personnalisés en série. Plus d’informations sur les ressources peuvent être trouvées ici.

Utiliser Godot en C ++

Godot vous permet également de développer votre projet directement en C ++ en utilisant son API, ce qui n’est pas possible avec Unity pour le moment. Par exemple, vous pouvez considérer l’éditeur de Godot Engine comme un « jeu » écrit en C ++ à l’aide de l’API Godot.

Si vous êtes intéressé par l’utilisation de Godot en C++, vous pouvez commencer à lire la page Développer en C++.