De Unity à Godot Engine

Ce guide fournit un aperçu de Godot Engine du point de vue d’un utilisateur de Unity, et vise à faciliter la migration de votre expérience dans Unity vers le monde de Godot.

Note

Cet article traite d'une ancienne version de Unity. Les Prefabs imbriqués ('Nested prefabs') sont utilisables depuis la version Unity 2018.3. Les Prefabs imbriqués sont analogues aux scènes de Godot. Cela permet d'ailleurs d'avoir une approche de la gestion des scenes similaire à Godot dans Unity.

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 Windows, macOS, X11 (Linux, *BSD)
OS (export)
  • Bureau : Windows, macOS, Linux
  • Mobile : Android, iOS, Windows Phone, Tizen
  • Web : WebAssembly or asm.js
  • Console : 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
Avantages notables
  • Immense communauté
  • Grande boutique en ligne de ressources

L’éditeur

Godot Engine est fourni avec un environnement de développement incluant un éditeur complet pour faire vos jeux. Les images ci-dessous montrent les deux éditeurs avec des blocs de couleur pour indiquer les fonctionnalités communes.

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

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, avec un format texte minimaliste, et sans métadonnées. Tout cela contribue à rendre Godot plus compatible avec les logiciels de gestion de versions tels que Git, Subversion ou encore 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 simple coup d'œil.

L'Inspecteur à Godot est plus minimal, il n'affiche que des propriétés. Grâce à cela, les objets peuvent exposer des paramètres plus utiles à l'utilisateur sans avoir à cacher de fonctionnalité dans les API de langage. De plus, Godot permet d'animer visuellement n'importe laquelle de ces propriétés. Il est possible de modifier les couleurs, les textures, les énumérations ou même les liens vers les ressources en temps réel sans avoir à écrire de code.

La barre d'outils en haut de l'écran est similaire dans les deux éditeurs, offrant un contrôle sur la vue du projet. Les projets dans Godot s'exécutent dans une fenêtre séparée, plutôt que dans l'éditeur (mais l'arbre et les objets peuvent toujours être explorés dans la fenêtre du débogueur).

Cette approche présente 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).
  • L'édition en direct est beaucoup plus pratique car les modifications apportées dans 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.
  • Le jeu en cours peut être exploré sous différents angles en basculant le bouton "Camera Override" dans la fenêtre de l'éditeur, qui basculera entre la vue de l'éditeur et la vue de la caméra du jeu.

Pour conclure, la barre d’outils située en haut de l'éditeur, comprend un menu pour le débogage distant. 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

Il s'agit de la différence la plus importante entre Godot Engine et Unity. Et c'est la fonctionnalité la plus appréciée des utilisateurs de Godot.

Travailler sur un 'niveau' dans Unity consiste habituellement à intégrer toutes les dépendances requises dans une scène et à les relier ensemble en leur attachant des composants et des scripts.

Le système de scène de Godot est superficiellement similaire à Unity. Un 'niveau' se compose d'un ensemble de nœuds, chacun avec son propre but : Sprite, Mesh, Light, etc. Cependant, dans Godot, les nœuds sont disposés en arbre. Chaque nœud peut avoir plusieurs enfants, ce qui fait de chacun une sous-scène de la scène principale. Cela signifie que vous pouvez composer une scène entière avec différentes scènes stockées dans différents fichiers.

Par exemple, pensez à un niveau de jeu 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 des fonctionnements 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 trois scènes séparées, plus petites, et les instancieriez dans la scène principale.

  1. Une scène pour le joueur uniquement.

Considérez le joueur comme un élément que nous aimerions utiliser dans différentes scènes mères (par exemple des scènes de 'niveau'). Dans notre cas, l'élément joueur nécessite au moins un nœud AnimatedSprite. Ce nœud contient les textures de sprite nécessaires à diverses animations (par exemple, une animation de marche).

  1. Une scène pour l'ennemi.

Un ennemi est aussi un élément que nous aimerions utiliser dans plusieurs scènes. C'est presque la même chose que le nœud Joueur(Player). Les seules différences sont le script (il a besoin de routines 'AI'(intelligence artificielle) pour générer le comportement de l'ennemi) et les textures de sprite utilisées par le nœud AnimatedSprite.

  1. Une scène niveau.

Une scène de niveau(Level) est composée de briques(Bricks) (pour les plates-formes), de pièces(Coins) (à collecter par le joueur) et d'un certain nombre d'instances de la scène ennemie(Enemy). Chaque instance est un nœud dans l'arborescence de la scène niveau(Level). Ces instances sont des ennemis distincts, qui ont initialement un comportement et une apparence communs tels que définis dans la scène ennemie(Enemy). Vous pouvez définir différentes propriétés pour chaque nœud ennemi(Enemy) (pour changer sa couleur, par exemple).

4. A Main scene. The Main scene would be composed of one root node with 2 children: a Player instance node, and a Level instance node. The root node can be anything, generally a "root" type such as "Node" which is the most global type, or "Node2D" (root type of all 2D-related nodes), "Spatial" (root type of all 3D-related nodes) or "Control" (root type of all GUI-related nodes).

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 Introduction à la physique).

  • Quels sont les avantages de ce système ? Ce système n'augmenterait-il pas potentiellement la profondeur de l'arbre de scène ? Et Unity ne vous permet-il pas déjà d'organiser des GameObjects en les plaçant dans des GameObjects vides ?

    • Le système de Godot est plus proche du célèbre paradigme orienté objet : Godot fournit un certain nombre de nœuds qui ne sont pas clairement des "Game Objects", mais ils fournissent à leurs enfants leurs propres capacités : c'est l'héritage.
    • Godot permet d'extraire un sous-arbre d'une scène pour en faire une scène à part entière. Ainsi, si un arbre de scène devient trop profond, il peut être divisé en sous-arbres plus petits. C'est mieux pour la ré-utilisabilité, car vous pouvez inclure n'importe quel sous-arbre comme un enfant de n'importe quel nœud. Mettre plusieurs GameObjects dans un GameObject vide dans Unity n'offre pas les mêmes fonctionnalités.

Organisation du projet

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

Il n'y a pas d'architecture de projet parfaite. N'importe quelle architecture peut fonctionner avec Unity comme avec Godot.

Cependant, une architecture commune pour les projets Unity est d'avoir un dossier Assets dans le répertoire racine qui contient plusieurs dossiers, un par type de asset : Audio, Graphiques, Modèles, Matériaux, Scripts, Scènes, etc.

Comme Godot permet de diviser les scènes en scènes plus petites, chaque scène et sous-scène existant sous forme de fichier dans le projet, nous vous recommandons d'organiser votre projet un peu différemment. Ce wiki fournit une page pour cela : Organisation du projet.

Où sont mes prefabs ?

Un préfab tel que fourni par Unity est un 'modèle' d'élément de la scène. Il est réutilisable, et chaque instance du préfab qui existe dans la scène a sa propre existence, mais toutes ont les mêmes propriétés que celles définies par le préfab.

Godot ne fournit pas de préfabs en tant que tels, mais la même fonctionnalité est fournie par son système de scène : Le système de scène est organisé sous forme d'arbre. Godot vous permet d'enregistrer n'importe quel sous-arbre d'une scène dans un fichier de scène. Cette nouvelle scène peut alors être instanciée autant de fois que vous le souhaitez, comme un enfant de n'importe quel nœud. Toute modification que vous apportez à cette nouvelle scène séparée sera appliquée à ses instances. Cependant, tout changement que vous apporterez à 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. 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. 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
  • Prefab -> Fichier de Scène réutilisable

Scripting : GDScript, C# et Visual Script

Design

Unity supporte C#. C# bénéficie de son intégration avec Visual Studio et possède des fonctionnalités intéressantes telles que le typage 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 Bases de GDScript et Questions fréquentes. 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 un arbre de scène en désordre. Envisagez de diviser toute 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 ! Plus d'informations ici.

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. Plus d'informations 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. Plus d'informations ici.

Unity possède également un type de données appelé ScriptableObject utilisé pour sérialiser les objets assets personnalisés. Son équivalent dans Godot est la classe de base pour toutes les ressources Resource. Créer un script qui hérite de Resource vous permettra de créer des objets sérialisables personnalisés. 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++.