Godot C'est un moteur de développement de jeux vidéo gratuit, open source, doté d'une communauté très active qui favorise son évolution constante. Contrairement à d'autres plateformes plus connues, telles que Unity ou Unreal Engine, Godot se distingue par sa légèreté, sa facilité d'apprentissage et son approche modulaire basée sur des nœuds. Cela en fait un excellent choix pour ceux qui souhaitent se lancer dans le développement de jeux vidéo sans complications inutiles.
Outre son architecture accessible, Godot permet de travailler de manière entièrement visuelle à la création de scènes et d'animations, sans pour autant renoncer au contrôle du code grâce à son langage GDScript, inspiré de Python. Cela facilite l'expérimentation, l'apprentissage progressif et le développement de prototypes fonctionnels dès le premier jour. Que vous veniez du monde du design, que vous appreniez à programmer ou que vous souhaitiez simplement donner vie à une idée, Godot vous offre l'environnement idéal pour vous lancer.
Étape 1 : Installation et configuration initiale de Godot
Avant de commencer à développer votre jeu vidéo en 2D, il est essentiel d'installer correctement Godot et de préparer votre environnement de travail. Cette étape vous garantit de disposer de tout le nécessaire pour créer, exécuter et organiser vos projets sans difficulté.
Télécharger Godot Engine
Godot ne nécessite pas d'installation classique. Vous pouvez télécharger le fichier exécutable directement depuis son site officiel https://godotengine.org/download en fonction de votre système d'exploitation (Windows, macOS ou Linux). Il suffit de décompresser le fichier ZIP et d'exécuter le fichier correspondant. Pour faciliter l'accès, vous pouvez déplacer le fichier exécutable dans un dossier accessible ou l'épingler à votre barre des tâches.
Créer un nouveau projet
Lorsque vous lancerez Godot pour la première fois, vous accéderez à la Chef de projet, d'où vous pourrez gérer vos projets. Pour en créer un nouveau :
- Cliquez sur « Nouveau projet ».
- Donnez un nom à votre jeu et choisissez le dossier dans lequel les fichiers seront enregistrés.
- Sélectionner « Créer un dossier » puis cliquez sur « Créer et modifier ».
L'éditeur principal de Godot s'ouvrira, et vous pourrez alors commencer à travailler. L'interface est divisée en plusieurs onglets (2D, 3D, Script, AssetLib…) et panneaux qui organisent les hiérarchies de nœuds, les propriétés, les scènes et les fichiers. Ne t’inquiète pas si cela te semble un peu intimidant au début : au fur et à mesure que tu avanceras, tu te familiariseras rapidement avec chaque section.
Étape 2 : Structure de base d'un jeu dans Godot
Il est essentiel de comprendre comment un projet est organisé dans Godot pour développer efficacement. Godot repose sur un système de nœuds et de scènes qui offre flexibilité et modularité lors de la création de jeux vidéo.
Scènes et nœuds : les éléments fondamentaux
Dans Godot, tout est construit à partir de nœuds. Un nœud représente un élément fonctionnel : un sprite, un son, une animation, une caméra, etc. Ces nœuds sont regroupés dans scènes, qui font office d'unités de contenu réutilisables (elles peuvent représenter des personnages, des menus, des niveaux ou le jeu dans son intégralité).
Chaque scène possède un nœud racine et peut contenir une hiérarchie de nœuds enfants. Vous pouvez enregistrer des scènes sous forme de modèles et les combiner entre elles, ce qui permet d'obtenir une structure claire et évolutive pour les jeux complexes.
Types de nœuds les plus courants dans les jeux en 2D
Pour les jeux en 2D, les nœuds les plus couramment utilisés sont généralement les suivants :
- Node2D : base pour les objets positionnables en 2D (tels que les sprites ou les éléments d'interface utilisateur).
- Sprite2D : affiche une image à l'écran.
- AnimatedSprite2D : permet d'utiliser des animations image par image.
- CollisionShape2D : définit des formes physiques permettant de détecter les collisions.
- Area2D : gère les événements tels que les collisions ou les actions du joueur.
- Camera2D : contrôle la vue du joueur dans des scènes plus grandes que l'écran.
Une utilisation correcte de cette hiérarchie vous permettra d'organiser les mécanismes de manière modulaire et de garantir la clarté et la lisibilité de votre projet.
Étape 3 : Création d'une scène principale
La première étape concrète de votre projet consiste à créer une scène principale, qui servira de point de départ au jeu. Dans Godot, cette scène peut contenir l'environnement, les éléments d'interface et les nœuds qui gèrent la logique générale.
Créer et enregistrer la scène principale
Commencez par créer une nouvelle scène à partir du menu supérieur (Scene > New Scene). Ajoutez un nœud racine de type Node2D et nommez-le Main. Ce nœud servira de base sur laquelle seront placés les autres éléments.
Enregistrez la scène (Scène > Enregistrer la scène sous…) sous le nom Main.tscn, dans un dossier intitulé « scenes », afin de garder votre projet bien organisé.
Définir la scène principale par défaut
Pour que Godot exécute cette scène au démarrage du jeu, accédez au menu Project > Project Settings, puis, dans l'onglet Application, sélectionnez la propriété Main Scene. Cliquez sur l'icône en forme de dossier et choisissez Main.tscn.
Cela garantit que, lorsque vous cliquez sur le bouton « Play », Godot charge votre scène principale comme point d'entrée du jeu.
Étape 4 : Ajouter un personnage jouable
Le joueur a besoin d'un personnage qu'il puisse contrôler à l'écran. Pour cela, vous allez créer une nouvelle scène avec un sprite et un composant de collision, puis vous allez la transformer en un personnage fonctionnel à l'aide de code.
Créer la scène du personnage
Créez une nouvelle scène (Scene > New Scene) et sélectionnez CharacterBody2D comme nœud racine. Renommez-la « Player ».
Dans Player, ajoutez les nœuds enfants suivants :
- Sprite2D : pour afficher l'image du personnage.
- CollisionShape2D : pour définir la zone de collision (choisissez une forme appropriée, telle que RectangleShape2D ou CapsuleShape2D).
Attribuez une texture au Sprite2D en faisant glisser une image depuis le panneau FileSystem. Ajustez également la taille de la zone de collision pour qu'elle corresponde à celle du sprite.
Enregistrez la scène sous le nom Player.tscn dans le dossier scenes.
Instancier le personnage dans la scène principale
Ouvrez la scène Main.tscn. Dans le panneau FileSystem, faites glisser la scène Player.tscn dans le nœud racine Main pour instancier le personnage.
Placez le nœud « Player » à l'emplacement de départ souhaité à l'écran. Ainsi, au démarrage du jeu, le personnage sera déjà visible et prêt à recevoir des instructions de déplacement.
Étape 5 : Programmer les mouvements du personnage
Maintenant que le personnage est présent sur la scène, il est temps de lui donner du mouvement. Pour cela, on utilise un script qui détecte les actions du joueur et met à jour sa position.
Ajouter le script de contrôle
Sélectionnez le nœud « Player » dans la scène Player.tscn, cliquez sur l'icône « Ajouter un script » (Attach Script) et enregistrez le fichier sous le nom Player.gd. Le script doit être écrit en GDScript, le langage propre à Godot.
Dans cette première approche, nous allons mettre en place un déplacement en 2D à l'aide des touches fléchées ou WASD, en contrôlant la vitesse à l'aide d'un vecteur.
Player.gd
étend CharacterBody2D
@export var speed := 200
func _physics_process(delta) :
var direction := Vector2.ZERO
if Input.is_action_pressed(« ui_right »):
direction.x += 1
if Input.is_action_pressed(« ui_left »):
direction.x -= 1
if Input.is_action_pressed(« ui_down »):
direction.y += 1
if Input.is_action_pressed(« ui_up »):
direction.y -= 1
self.velocity = direction.normalized() * speed
move_and_slide()
Régler les paramètres de mouvement
Vous pouvez personnaliser la vitesse du personnage en ajustant la variable correspondante. Ce mouvement sera fluide et adapté à la fréquence d'images, grâce à la méthode _physics_process.
Étape 6 : Mettre en place la détection des collisions
Pour que les mouvements du personnage soient réalistes et qu’il ne traverse pas d’autres éléments du décor, nous devons ajouter une détection des collisions. Godot permet de le faire à l’aide de nœuds CollisionShape2D et de corps physiques tels que StaticBody2D ou TileMap.
Ajouter des collisions au personnage
Dans la scène du joueur (Player.tscn), assurez-vous qu'il existe un nœud enfant de type CollisionShape2D avec une forme (par exemple, un cercle ou un rectangle) qui corresponde à la taille du personnage. Cela permettra au moteur de détecter les limites du personnage et d'agir en conséquence en cas de collision.
Exemple de structure dans la scène du joueur
Joueur (CharacterBody2D)
├── Sprite2D
├── CollisionShape2D (Shape : CapsuleShape2D ou RectangleShape2D)
└── Script : Player.gd
Ajouter des collisions à l'environnement
Les éléments du décor qui ne doivent pas être traversés (tels que les murs, les sols ou les obstacles) doivent également disposer de nœuds CollisionShape2D. Si vous utilisez une TileMap, vous pouvez définir les collisions depuis l'éditeur de tilesets, en attribuant une forme à chaque tuile qui le nécessite.
Une fois ces étapes effectuées, le personnage ne pourra plus traverser d'autres objets solides dans le jeu. La physique et le système de collisions de Godot se chargeront d'empêcher tout chevauchement entre les corps.
Étape 7 : Ajouter des animations au personnage
Pour améliorer l'expérience visuelle du jeu, il est essentiel de doter le personnage d'animations qui reflètent ses actions (marcher, rester immobile, sauter, etc.). Godot facilite cette tâche grâce au nœud AnimatedSprite2D, qui permet de gérer différentes animations à partir de feuilles de sprites.
Créer les animations dans l'éditeur
Dans la scène du joueur, remplacez le nœud Sprite2D par un AnimatedSprite2D. Chargez une feuille de sprites (spritesheet) contenant les différentes positions du personnage et configurez les animations à partir du panneau d'animations du nœud.
Chaque animation doit porter un nom unique (par exemple, « idle », « walk », « jump ») et être composée des images correspondant à chaque phase du mouvement.
Charger et configurer des animations dans l'éditeur (il ne s'agit pas de code exécutable)
AnimatedSprite2D
├── Animation : « idle » → Images : sprite_0, sprite_1
├── Animation : « walk » → Images : sprite_2, sprite_3, sprite_4
Modifier les animations à partir du script
Pour que le personnage réagisse aux actions du joueur et change d'animation de manière dynamique, modifiez le script du joueur afin de mettre à jour l'animation en fonction de son état (en mouvement ou à l'arrêt, par exemple). Pour ce faire, utilisez la méthode .play(« nom_animation ») de la classe AnimatedSprite2D.
Player.gd (avec animation)
étend CharacterBody2D
@export var speed := 200
func _physics_process(delta) :
var direction := Vector2.ZERO
if Input.is_action_pressed(« ui_right »):
direction.x += 1
if Input.is_action_pressed(« ui_left »):
direction.x -= 1
if Input.is_action_pressed(« ui_down »):
direction.y += 1
if Input.is_action_pressed(« ui_up »):
direction.y -= 1
self.velocity = direction.normalized() * speed
move_and_slide()
si direction != Vector2.ZERO :
$AnimatedSprite2D.play(« walk »)
d'autre part :
$AnimatedSprite2D.play(« idle »)
L'utilisation d'animations apporte non seulement du dynamisme au jeu, mais améliore également la clarté visuelle pour le joueur, en lui indiquant ce qui se passe à chaque instant.
Étape 8 : Ajouter des obstacles et des limites au décor
Pour que le jeu commence à présenter un certain défi et à avoir une structure, il est important d'ajouter des éléments tels que des obstacles qui bloquent le passage du personnage et des limites qui délimitent la zone de jeu. Dans Godot, cela se fait à l'aide de nœuds de collision et de sprites qui représentent visuellement ces objets.
Placer des obstacles avec collision
Vous pouvez ajouter des nœuds StaticBody2D pour représenter des objets statiques que le joueur ne peut pas traverser (par exemple, des murs, des pierres, des plates-formes). À chacun de ces nœuds, il faut ajouter un CollisionShape2D et une forme géométrique correspondante (comme un rectangle ou un cercle).
Vous pouvez également utiliser des nœuds TileMap, qui permettent de dessiner des décors à partir de tuiles. Les tuiles peuvent être configurées pour inclure automatiquement des collisions, ce qui facilite grandement la création de niveaux complets.
var mur := StaticBody2D.new()
var collision := CollisionShape2D.new()
var forme := RectangleShape2D.new()
forma.size = Vector2(64, 64)
colision.shape = forme
muro.add_child(colision)
add_child(mur)
Créer des limites d'écran
Pour empêcher le joueur de sortir de la zone de jeu, vous pouvez placer des limites invisibles autour du décor. Il peut s'agir de StaticBody2D avec collision ou de paramètres définis au sein de la caméra (tels que les limites de déplacement de Camera2D).
Il est également recommandé de définir une zone de « mort » en dehors du niveau, de sorte que si le joueur tombe par erreur, le niveau redémarre ou qu’il perde une vie.
Réinitialisation du niveau à la sortie de la zone de jeu
func _process(delta) :
si global_position.y > 1000 :
get_tree().reload_current_scene()
Grâce à ces outils, vous pouvez structurer le scénario de manière à guider le joueur, à lui proposer des défis et à rendre le jeu plus complet et plus fonctionnel.
Étape 9 : Ajouter des objets à collecter ou des points
Dans de nombreux jeux vidéo en 2D, la possibilité de collecter des objets constitue un élément clé, que ce soit pour augmenter le score, débloquer des éléments ou passer au niveau suivant. Dans Godot, ces objets peuvent être implémentés sous forme de nœuds individuels dotés d'une collision et d'une logique de collecte.
Créer des objets à collectionner
Les objets à collecter peuvent être représentés à l'aide d'Area2D, qui détecte lorsque le joueur entre en contact avec eux. À chaque Area2D, on peut associer un sprite visuel (Sprite2D) et une forme de collision (CollisionShape2D). Lorsqu'une collision est détectée, vous pouvez exécuter une fonction pour supprimer l'objet et ajouter des points au score.
ObjetRecollectable.gd
étend Area2D
func _on_body_entered(body) :
si body.name == « Player » :
queue_free()
get_tree().call_group(« HUD », « additionner_les_points », 10)
Gérer le système de notation
Pour compter les points, tu peux utiliser une variable globale ou un signal qui met à jour une étiquette (Label) à l'écran. Si tu utilises un système à scènes multiples, il peut être utile de créer un nœud « autoload » (singleton) pour enregistrer le score d'un niveau à l'autre.
De plus, tu peux utiliser des signaux pour signaler l'événement de collecte au HUD et mettre à jour le score en temps réel.
Exemple de HUD affichant le score
étend CanvasLayer
var points = 0
func additionner_points(valeur) :
points += valeur
$Label.text = str(points)
Ce système de base de collectibles peut facilement être étendu pour inclure des objets spéciaux, des clés, des pièces de monnaie ou des objets dotés de propriétés uniques, en fonction des mécanismes de votre jeu.
Étape 10 : Effets visuels et sonores de base
Les effets visuels et sonores améliorent considérablement l'expérience du joueur et apportent de la clarté aux actions qui se déroulent à l'écran. Bien que Godot permette de créer des systèmes avancés de particules et d'audio, pour une première version fonctionnelle, vous pouvez intégrer des éléments simples mais efficaces.
Ajouter des effets visuels simples
Vous pouvez utiliser des nœuds tels que Particles2D ou AnimatedSprite2D pour représenter des explosions, des éclairs ou des impacts. Ceux-ci sont déclenchés lors d'événements importants (par exemple, lorsque vous ramassez un objet, que vous sautez ou que vous subissez des dégâts). Les effets peuvent être reproduits à un emplacement précis, puis supprimés automatiquement.
Lire une animation d'effet visuel
func afficher_effet(position) :
var effet = preload(«res://effets/impact.tscn»).instantiate()
effet.position = position
get_parent().add_child(effet)
Intégrer des sons de jeu
Godot permet de lire des sons à l'aide du nœud AudioStreamPlayer. Vous pouvez avoir plusieurs nœuds de ce type dans chaque scène (par exemple, un pour les effets, un autre pour la musique). Associez des fichiers audio .wav ou .ogg à chacun d'entre eux et lancez-les à partir du script correspondant lorsqu'une action se produit.
Lire un son de collecte
func _on_recolectado() :
$AudioStreamPlayer.play() # Uniquement s'il s'agit d'un enfant direct
ou bien, modifie l'itinéraire :
get_node(« Chemin/Vers/AudioStreamPlayer »).play()
Utiliser les effets sonores et visuels avec modération et discernement permet d'améliorer le retour d'information du jeu sans surcharger la scène ni distraire le joueur.
Étape 11 : Écran d'accueil et redémarrage du jeu
La présence d'un écran d'accueil améliore la présentation du jeu et permet au joueur de commencer quand il le souhaite. De plus, une bonne gestion du redémarrage après une défaite ou la fin d'une partie est essentielle pour l'expérience utilisateur.
Créer un écran d'accueil simple
Tu peux créer une scène indépendante comprenant un arrière-plan, un titre et un bouton qui, lorsqu'on clique dessus, permet de revenir à la scène principale du jeu. Cet écran peut servir de « main_scene » initiale au lancement du jeu.
Changement de scène depuis l'écran d'accueil
func _on_boton_jugar_pressed() :
get_tree().change_scene_to_file(«res://scènes/niveau_1.tscn»)
Reprendre la partie après avoir perdu
Lorsque le joueur perd, vous pouvez afficher un écran ou un message proposant de recommencer. Cela peut se faire à l'aide d'un nouveau bouton ou en détectant une pression sur une touche, puis en rechargeant la scène en cours.
Redémarrer le jeu à l'aide du bouton
func redémarrer_jeu() :
get_tree().reload_current_scene()
Disposer d'un déroulement de jeu bien défini (début → partie → fin → redémarrage) facilite la navigation et renforce chez le joueur le sentiment d'achèvement ou d'envie de réessayer.
Étape 12 : Exporter votre jeu pour le partager
Une fois que votre jeu est terminé et testé, il est temps de l'exporter pour que d'autres personnes puissent y jouer. Godot facilite ce processus en proposant de multiples options d'exportation pour différentes plateformes.
Configurer le modèle d'exportation
Avant d'exporter, assure-toi d'avoir installé les modèles d'exportation adaptés à votre version de Godot. Ces modèles permettent de compiler le jeu pour des plateformes telles que Windows, Linux, macOS, HTML5 ou Android.
Vous pouvez les télécharger depuis le menu principal :
Éditeur → Gestionnaire de modèles d'exportation → Télécharger et installer
Une fois les installations terminées, vous pouvez accéder au menu d'exportation.
Chemin d'accès : Éditeur → Projet → Exporter
Ajouter une nouvelle configuration pour la plateforme souhaitée
Générer le fichier exécutable ou le fichier web
Dans le menu d'exportation, choisissez la plateforme souhaitée (par exemple, Windows Desktop ou HTML5) et définissez les options de base telles que le nom du fichier, l'icône du jeu et le répertoire de sortie. Cliquez ensuite sur Exporter le projet et enregistrez le fichier final que vous pouvez partager.
Pour HTML5, Godot génère un dossier contenant des fichiers .html, .wasm et .pck, que vous pouvez facilement mettre en ligne sur des services tels que Itch.io, Netlify ou GitHub Pages.
Personnalisez les options d'exportation et enregistrez le fichier exécutable final
Pour Windows : fichier .exe
Pour le Web : dossier contenant index.html + .wasm + .pck
Exporter correctement votre projet permet à d'autres personnes d'en profiter sans avoir besoin d'installer Godot.
Conclusions
Créer des jeux vidéo en 2D avec Godot Engine est une expérience enrichissante tant pour ceux qui débutent dans le développement que pour ceux qui souhaitent explorer une alternative puissante et gratuite. Ce guide a présenté, étape par étape, les bases nécessaires pour donner vie à un projet à partir de zéro, en soulignant les avantages d’un moteur open source qui privilégie la créativité plutôt que la complexité technique.
La maîtrise des bases — telles que l'interface, les nœuds, les scènes, les scripts et le système de physique — permet de poser des fondations solides sur lesquelles construire des projets plus ambitieux. De plus, la flexibilité de Godot et sa communauté dynamique en font un outil très prometteur pour l'avenir, idéal pour le prototypage, l'apprentissage ou la publication de jeux indépendants.
La prochaine étape est claire : s'entraîner, expérimenter et continuer à explorer les nombreuses possibilités offertes par le moteur. À mesure que vous gagnerez en confiance, vous pourrez intégrer de nouveaux éléments tels que des animations complexes, du son, des niveaux multiples, des menus interactifs ou l'intégration à des services en ligne. La seule limite, c'est votre imagination.
Avec de la persévérance et de la curiosité, cette première approche peut constituer le point de départ d'une carrière créative dans le monde du développement de jeux vidéo.
Español 
English (UK) 
Français