Catégories
Guide

Godot Engine, travailler en équipe avec Git

Aujourd’hui, nous allons découvrir un outil pour collaborer plus facilement entre développeur·se·s. J’ai nommé Git!

  • Auteur de l’article Par Greaby
  • Date de l’article 16 avril 2021
  • Date de l’article 6 minutes

Cet article a été écrit avec Godot Engine 3.2, il est possible que certains éléments présenté ici soient différents dans les versions futures.

Vous avez peut-être déjà dû rencontrer ce problème. Vous participez à une Game Jam, vous et votre équipe travaillez sur votre jeu. Il arrive un moment où vous devez mettre en commun votre code. L’étape est fastidieuse, vous avez créé préalablement un dossier de sauvegarde de votre projet.

Aujourd’hui, nous allons découvrir un outil pour collaborer plus facilement entre développeur·se·s. J’ai nommé Git!

Git

Je ne vais pas vous faire une explication complète de Git ici. Pour cela, je vous laisse aller chercher plus d’informations sur le sujet et comment l’installer sur votre ordinateur.

En résumé, Git est un système de gestion de version (aussi appelé VCS). Il va vous offrir plusieurs avantages pour travailler sur votre projet.

  • Historique : Vous allez pouvoir sauvegarder chaque modification de votre code séparément. En cas d’erreur, vous pourrez voir l’historique et revenir en arrière facilement.
  • Transparence : Chaque modification est associée à la personne qui l’a faite. Vous pourrez donc savoir qui a travaillé sur quoi dans le projet.
  • Décentralisé : Chaque personne possède une copie complète du dépôt Git dans son espace de travail. Le risque de perte de données est diminué.
  • Gestion de conflits : Parfois, deux personnes éditent le même fichier. Git dispose d’un outil pour gérer ce genre de cas et fusionner le travail de l’équipe.

Si vous débutez sur Git, je vous invite à vous rendre sur ce site pour apprendre les bases : try.github.io

Git dans Godot

Vous pouvez utiliser Git de deux manières. Soit, avec une extension développée par la communauté qui intègre le gestionnaire de version dans l’interface de Godot. Soit, séparément du moteur de jeu.

Je reviendrais peut-être dans un autre article sur les plug-ins disponibles. Dans cet article, je vais vous parler de la méthode que j’utilise personnellement. C’est à dire, Git directement en ligne de commande.

Des outils graphiques, tels que Sourcetree ou GitHub Desktop, sont disponibles si vous n’êtes pas familier avec un terminal.

Godot est conçue pour être le plus compatible possible avec des gestionnaires de version. Tous ces fichiers sont en texte plein. Prenez par exemple un de vos fichiers de scène (.tscn) et ouvrez-le avec un éditeur de texte.

Godot ne contient pas de fichier binaire. En effet, ces fichiers seraient très difficiles à gérer en cas de conflit.

Pour commencer, nous allons initialiser un dépôt Git pour notre jeu.

Pour cela, rendez-vous dans le dossier du projet avec un terminal, et tapez la commande :

git init

Un dossier .git sera normalement apparu.

Certains fichiers n’ont pas besoin d’être sauvegardés

Avant de commencer à sauvegarder nos modifications, nous allons devoir ignorer certains fichiers du projet.

Godot génère quelques fichiers automatiquement, par exemple, les éléments du dossier « .import »

Pour cela, nous allons utiliser un fichier nommé .gitignore qui permet de définir les fichiers et dossiers que nous souhaitons ignorer dans le projet.

Un modèle de base existe déjà, vous pouvez le trouver ici : https://github.com/github/gitignore/blob/master/Godot.gitignore

Pour cela, copiez le dans un fichier nommé « .gitignore ».

Sauvegarder ses modifications

Une fois que vous avez terminé de travailler sur une fonctionnalité de votre jeu. Vous pouvez la sauvegarder en utilisant la commande suivante :

git commit -m "description de la modification"

Envoyer vos modifications sur un dépôt

Les modifications que vous avez « commit » sont, pour l’instant, uniquement sauvegardées sur votre ordinateur local. Pour collaborer avec d’autres personnes, vous devez les envoyer sur un serveur distant. Plusieurs services gratuits vous permettent de gérer en ligne vos dépôts Git. Voici les plus courants :

Vous trouverez toutes les informations sur comment connecter votre projet en créant un nouveau dépôt sur l’un de ces services.

Une fois que votre projet est connecté, utilisez cette commande pour envoyer vos commits.

git push

En cas de conflit ?

Il arrive que deux personnes éditent le même fichier. Dans ce genre de cas, nous avons un conflit. La plupart du temps, quand les modifications se situent à des endroits différents dans le fichier, Git résout lui-même le conflit.

Bien que le terme puisse faire peur, il s’agit de quelque chose de très simple. Quand Git ne peut pas gérer lui-même le conflit, nous allons devoir choisir quelles modifications nous souhaitons conserver dans le projet.

Voilà à quoi ressemble un conflit, dans cet exemple deux personnes ont édité la valeur d’une variable.

<<<<<<< HEAD
var speed = 200
=======
var speed = 120
>>>>>>> alice

Alice a envoyé une modification de la variable speed. Bob avait, entre temps, aussi édité cette variable. Nous devons choisir laquelle des deux versions nous souhaitons conserver.

<<<<<<< HEAD
var speed = 200
=======

Corresponds à la version actuelle sur le dépôt (avec la modification de Bob).

=======
var speed = 120
>>>>>>> alice

Corresponds à la modification d’Alice.

Je vous conseiller d’utiliser un éditeur externe pour résoudre vos conflits, par exemple VSCodium qui permet également de le traiter à l’aide d’une interface.

Le cas particulier des fichiers de scène .tscn

Je vous ai montré la résolution de conflit dans un script. Les fichiers .tscn correspondent à vos différentes scènes. Ceux-ci peuvent être particulièrement compliqués à gérer si l’on ne comprend pas bien leurs structures.

Un fichier .tscn se découpe en deux parties. La première (rose) contient les ressources liées au projet, par exemple une texture ou un script. La deuxième (bleue) contient votre arbre de scène et toutes les propriétés modifiées de vos nœuds.

Dans cet exemple, j’ai une scène Player avec pour enfants un Sprite et une boite de collision.

Le nœud Player a un script attaché (id=1) et notre Sprite utilise une image PNG (id=2). La boite de collision a une sous-ressource pour définir sa forme.

Comment gérer un conflit de scène ? Premièrement, fermez Godot. En effet, le moteur ne lit pas les modifications du fichier et les écrasera si vous sauvez la scène depuis Godot.

Ouvrez votre fichier .tscn directement dans un éditeur de texte.

Dans cet exemple, Bob a remplacé le Sprite par un Animated Sprite tandis que Alice a modifié la texture du Sprite et a changé l’ordre des éléments de la scène.

Nous souhaitons garder le Sprite animé donc nous choisissons la modification courante. Je profite également de supprimer le nœud Sprite qui ne nous sert plus à rien.

Voilà à quoi ressemble notre scène après la résolution.

[gd_scene load_steps=4 format=2]
[ext_resource path="res://main.gd" type="Script" id=1]
[sub_resource type="SpriteFrames" id=2]
animations = [ {
"frames": [  ],
"loop": true,
"name": "default",
"speed": 5.0
} ]
[sub_resource type="CapsuleShape2D" id=1]
radius = 19.0064
[node name="Player" type="KinematicBody2D"]
script = ExtResource( 1 )
[node name="AnimatedSprite" type="AnimatedSprite" parent="."]
frames = SubResource( 2 )
[node name="CollisionShape2D" type="CollisionShape2D" parent="."]
shape = SubResource( 1 )

Vérifiez, en deuxième étape, que tous les id de ressource sont uniques et bien liés aux bons éléments de la scène. Deux ressources peuvent se retrouver avec le même id ou être connectées aux mauvais nœuds.

Dans notre cas, les ressources Script, SpriteFrames et CapsuleShape sont bien connectées aux bons endroits. Maintenant que le fichier de scène est correct, vous pouvez le rouvrir dans Godot.

Pour faciliter la gestion de ce genre de situation, je vous conseille de bien communiquer avec votre équipe sur les modifications que vous effectuez dans les scènes. Éviter au maximum de travailler en même temps sur une scène.

Je vous conseille également de garder vos scènes les plus petites possible en découpant un maximum vos éléments en scènes et sous-scènes et en profitant des fonctionnalités d’encapsulation de Godot Engine.

Conclusion

Git est un sujet très vaste, je pourrais encore vous parler de beaucoup d’autre fonctionnalité telle que les plug-ins Git intégrés à Godot, la gestion des fichiers volumineux, l’organisation en branche, les scriptes de déploiement, etc.

J’espère en tout cas vous avoir guidé sur une utilisation basique de Git et sur les choses à faire attention quand on collabore à plusieurs avec Godot Engine.

N’hésitez pas à me faire vos retours sur les réseaux et me dire si vous souhaitez que j’approfondisse le sujet!