Godot Engine pour débutants : créer un jeu vidéo 2D puis 3D avec GDScript, étape par étape

Godot est un moteur de jeu vidéo gratuit et open source qui permet de créer des jeux 2D et 3D complets, du prototype à la version exportée pour PC, mobile ou navigateur. Il combine un éditeur visuel, un système de nœuds très intuitif et un langage de script simple, GDScript, ce qui en fait l’un des meilleurs points d’entrée pour créer un jeu vidéo sans budget.

Ce guide s’adresse aux débutants complets, aux développeurs qui viennent d’un autre langage et aux créateurs qui veulent passer de l’idée à un jeu jouable. Vous y découvrirez la logique des nœuds et des scènes, les bases du GDScript, la création d’un personnage de jeu 2D avec gravité et saut, les collisions, les signaux, l’interface, le son et l’export.

Qu’est-ce que Godot Engine ?

Godot Engine est un moteur de jeu multiplateforme distribué sous licence MIT : gratuit, sans redevance, modifiable. Il fournit un éditeur complet pour construire des niveaux, animer, programmer et exporter des jeux 2D et 3D. Son architecture repose sur des nœuds assemblés en scènes, et ses scripts s’écrivent en GDScript ou en C#.

L’éditeur est léger, se télécharge en quelques minutes depuis godotengine.org et ne demande pas d’installation lourde. Il fonctionne sur Windows, macOS et Linux.

Deux caractéristiques font sa réputation :

• Une 2D native : Godot traite la 2D comme un moteur à part entière, avec des unités en pixels, des outils de tuiles et une physique dédiée, et non comme de la 3D « aplatie ».
• La composition par scènes : un ennemi, une pièce à ramasser ou un menu sont des scènes indépendantes, que l’on teste seules puis que l’on instancie autant de fois que nécessaire.

Pourquoi choisir Godot comme moteur de jeu gratuit ?

• Aucun coût : ni licence, ni pourcentage sur les ventes, quel que soit le succès du jeu.
• Prise en main rapide : l’interface est claire et le GDScript est pensé pour le jeu vidéo.
• Idéal pour la 2D : jeux de plateforme, puzzles, jeux vue de dessus, jeux narratifs.
• 3D accessible : suffisante pour des jeux indépendants, des prototypes et des projets pédagogiques.
• Export multiplateforme : un même projet vers PC, Mac, Linux, Android, iOS et le web.
• Communauté active : documentation officielle complète, nombreux tutoriels et ressources libres.

Pour une application mobile classique, sans logique de jeu, un framework d’interface comme Flutter sera plus adapté ; Godot se concentre sur les jeux et les expériences interactives.

Les bases de Godot : nœuds, scènes et interface

L’éditeur en un coup d’œil

• Le dock Scène (en haut à gauche) affiche l’arbre des nœuds de la scène ouverte.
• Le dock Système de fichiers (en bas à gauche) liste les ressources du projet, toutes situées sous le chemin res://.
• La vue principale (au centre) bascule entre les espaces 2D, 3D, Script et AssetLib.
• L’Inspecteur (à droite) affiche et modifie les propriétés du nœud sélectionné.
• Le panneau inférieur regroupe la sortie, le débogueur, l’animation et l’audio.

Raccourcis indispensables : F5 lance le projet, F6 lance la scène en cours, F8 arrête l’exécution.

Les nœuds les plus utilisés en 2D

Nœud	Rôle
Node2D	Nœud de base positionnable en 2D, sert souvent de racine
Sprite2D / AnimatedSprite2D	Affiche une image / une animation image par image
CharacterBody2D	Corps contrôlé par script : joueur, ennemis
StaticBody2D	Élément fixe : sol, murs, plateformes
RigidBody2D	Objet soumis à la physique : caisse, balle
Area2D	Zone de détection sans collision physique : pièce, piège, sortie
CollisionShape2D	Forme de collision, obligatoire pour les corps et les zones
Camera2D	Caméra, qui peut suivre le joueur
Timer	Minuteur qui émet un signal à intervalles réguliers
AudioStreamPlayer2D	Son positionné dans l’espace
Label, Button, CanvasLayer	Interface : textes, boutons, calque d’interface fixe

Les tuiles de décor se gèrent avec un nœud de carte de tuiles (TileMapLayer dans les versions récentes de Godot 4) associé à un TileSet, dans lequel on définit les collisions de chaque tuile.

Comment créer un jeu vidéo avec Godot : les étapes

Construisons le cœur d’un jeu de plateforme 2D : un personnage qui court, saute et ramasse des pièces.

Étape 1 — Créer le projet et configurer les contrôles

Dans le gestionnaire de projets, cliquez sur Nouveau projet, choisissez un dossier vide et le moteur de rendu proposé par défaut. Ouvrez ensuite Projet > Paramètres du projet > Contrôles (Input Map) et créez trois actions : gauche, droite et sauter, associées aux touches de votre choix (flèches, Q/D, espace) et éventuellement à une manette.

Utiliser des actions plutôt que des touches codées en dur permet de changer les contrôles sans toucher au code.

Étape 2 — Créer la scène du joueur

Créez une nouvelle scène avec un nœud racine CharacterBody2D, renommé Joueur. Ajoutez-lui en enfants :

1. un AnimatedSprite2D, avec des animations idle, course et saut créées à partir de votre feuille de sprites ;
2. un CollisionShape2D avec une forme de capsule ou de rectangle ajustée au personnage ;
3. une Camera2D, pour que la vue suive le joueur.

Enregistrez la scène sous res://joueur/joueur.tscn.

Étape 3 — Écrire le script de déplacement en GDScript

Sélectionnez le nœud Joueur, cliquez sur l’icône d’ajout de script et collez ce code :

extends CharacterBody2D

@export var vitesse: float = 300.0
@export var force_saut: float = -450.0

var gravite: float = ProjectSettings.get_setting("physics/2d/default_gravity")

@onready var sprite: AnimatedSprite2D = $AnimatedSprite2D


func _physics_process(delta: float) -> void:
	# Gravité : le personnage tombe tant qu'il ne touche pas le sol
	if not is_on_floor():
		velocity.y += gravite * delta

	# Saut, uniquement depuis le sol
	if Input.is_action_just_pressed("sauter") and is_on_floor():
		velocity.y = force_saut

	# Déplacement horizontal : -1 (gauche), 0 ou 1 (droite)
	var direction := Input.get_axis("gauche", "droite")
	velocity.x = direction * vitesse

	move_and_slide()
	_mettre_a_jour_animation(direction)


func _mettre_a_jour_animation(direction: float) -> void:
	if direction != 0:
		sprite.flip_h = direction < 0
	if not is_on_floor():
		sprite.play("saut")
	elif direction != 0:
		sprite.play("course")
	else:
		sprite.play("idle")

Points clés :

• _physics_process(delta) est appelée à chaque image de physique ; delta est le temps écoulé, qui rend le mouvement indépendant de la fréquence d’affichage.
• velocity est la vitesse du corps ; move_and_slide() déplace le personnage en gérant les collisions et les pentes.
• @export rend la variable modifiable dans l’Inspecteur, pour régler la vitesse sans toucher au code.
• @onready récupère le nœud enfant quand la scène est prête ; $AnimatedSprite2D est un raccourci vers ce nœud.

Étape 4 — Construire le niveau

Créez une scène Niveau avec un Node2D racine. Ajoutez un nœud de carte de tuiles, créez un TileSet à partir de votre image de décor et ajoutez une couche physique pour que les tuiles de sol aient une collision. Peignez ensuite le niveau directement dans la vue 2D.

Faites glisser joueur.tscn depuis le système de fichiers dans la scène : le joueur est instancié. Lancez la scène avec F6 : votre personnage court et saute sur les plateformes.

Pour la profondeur, ajoutez un décor en parallaxe : plusieurs couches d’arrière-plan qui défilent à des vitesses différentes.

Étape 5 — Ajouter des pièces avec les signaux

Créez une scène Piece avec un Area2D racine, un sprite et un CollisionShape2D. Sélectionnez l’Area2D, ouvrez l’onglet Nœud > Signaux et connectez le signal body_entered au script de la pièce :

extends Area2D

signal ramassee(valeur: int)

@export var valeur: int = 1


func _on_body_entered(body: Node2D) -> void:
	if body.name == "Joueur":
		ramassee.emit(valeur)
		queue_free()  # supprime la pièce de la scène

Le niveau (ou un script global) écoute le signal ramassee pour augmenter le score. Ce découplage est au cœur de Godot : la pièce ne sait pas qui gère le score, elle se contente d’annoncer qu’elle a été ramassée.

Étape 6 — Instancier des objets par le code

Pour faire apparaître des ennemis ou des obstacles à intervalles réguliers, combinez un Timer et l’instanciation :

extends Node2D

const ENNEMI := preload("res://ennemis/ennemi.tscn")


func _on_timer_timeout() -> void:
	var ennemi := ENNEMI.instantiate()
	ennemi.position = Vector2(randf_range(50, 1100), -50)
	add_child(ennemi)

C’est exactement la mécanique d’un jeu de course où des voitures apparaissent aléatoirement devant le joueur.

Les bases du GDScript à connaître

GDScript reprend les codes de Python : l’indentation délimite les blocs, pas d’accolades ni de points-virgules. Les notions à maîtriser en premier :

var vie: int = 3                     # variable typée
const VIE_MAX := 5                   # constante
var inventaire: Array[String] = ["clé", "potion"]
var stats := {"force": 10, "agilite": 7}   # dictionnaire

enum Etat { REPOS, COURSE, SAUT }    # énumération
var etat := Etat.REPOS

func subir_degats(montant: int) -> void:
	vie = max(vie - montant, 0)
	if vie == 0:
		print("Partie terminée")

func decrire_etat() -> String:
	match etat:
		Etat.REPOS:
			return "Au repos"
		Etat.COURSE:
			return "En course"
		_:
			return "En l'air"

Retenez aussi les boucles for objet in inventaire: et while, la conversion de type (str(score), int("42")), la concaténation ("Score : " + str(score)) et la portée des variables : une variable déclarée dans une fonction n’existe que dans cette fonction.

Typer ses variables (: int, -> void) n’est pas obligatoire, mais c’est fortement conseillé : l’éditeur complète mieux le code et signale les erreurs avant l’exécution.

Interface, son, 3D et export du jeu

Interface et menus

Placez l’interface (score, barre de vie) dans un CanvasLayer pour qu’elle reste fixe à l’écran pendant que la caméra bouge. Une barre de vie se réalise avec un nœud ProgressBar ou TextureProgressBar mis à jour par un signal émis par le joueur.

Pour le menu d’accueil, créez une scène dédiée avec des boutons, puis changez de scène par le code :

func _on_bouton_jouer_pressed() -> void:
	get_tree().change_scene_to_file("res://niveaux/niveau_1.tscn")

func _on_bouton_quitter_pressed() -> void:
	get_tree().quit()

Les données partagées entre scènes (score total, dernier niveau atteint) se placent dans un script Autoload, déclaré dans les paramètres du projet et accessible partout.

Son et musique

Un nœud AudioStreamPlayer joue la musique de fond ; AudioStreamPlayer2D joue un bruitage dont le volume dépend de la distance au joueur. Organisez les volumes par bus audio (musique, effets) pour proposer des réglages séparés au joueur.

Passer à la 3D

Les principes restent identiques : CharacterBody3D, Camera3D, MeshInstance3D, DirectionalLight3D et un WorldEnvironment pour le ciel et l’ambiance. Le nœud GridMap construit des niveaux modulaires en 3D, l’équivalent des tuiles en 2D : parfait pour un labyrinthe. Les modèles 3D peuvent être importés depuis un logiciel de modélisation au format glTF.

Exporter et partager votre jeu

Ouvrez Projet > Exporter, ajoutez un préréglage par plateforme (Windows, Linux, macOS, Web, Android…) et téléchargez les modèles d’exportation correspondant à votre version de Godot si l’éditeur le demande. Définissez l’icône, le nom et la version, puis exportez. Pour un export web, le jeu se publie sur une page HTML, pratique pour le partager sur les plateformes de jeux indépendants. Pour Android, il faut en plus configurer le SDK Android et une clé de signature.

Pensez aussi au redimensionnement de la fenêtre : dans les paramètres du projet, la rubrique Affichage > Fenêtre permet de choisir le mode d’étirement (stretch) pour que le jeu garde ses proportions sur tous les écrans.

Les erreurs fréquentes des débutants sur Godot

Erreur	Cause	Solution
Le personnage traverse le sol	CollisionShape2D manquant ou tuiles sans couche physique	Ajouter les formes de collision au joueur et au TileSet
Avertissement jaune sur un nœud	Nœud mal configuré (forme de collision absente, par exemple)	Lire l’avertissement en survolant l’icône
« Invalid access to property or key »	Nœud introuvable (mauvais chemin après un renommage)	Vérifier le chemin $Nom ou utiliser les noms uniques
Erreur d’indentation	Mélange d’espaces et de tabulations	Garder un seul type d’indentation dans tout le script
Mouvement saccadé ou dépendant du PC	Déplacement sans delta ou dans _process	Utiliser _physics_process(delta) et move_and_slide()
Tutoriel qui ne fonctionne pas	Tutoriel écrit pour Godot 3	Vérifier la version, adapter les noms (KinematicBody2D est devenu CharacterBody2D)
Projet qui ne s’exporte pas	Modèles d’exportation non installés	Éditeur > Gérer les modèles d’exportation

En formation, le conseil qui revient le plus souvent : une scène par élément de jeu, testée seule avec F6 avant d’être assemblée. C’est la meilleure protection contre les bugs difficiles à localiser.

Godot, Unity ou Unreal Engine : quel moteur choisir ?

Critère	Godot	Unity	Unreal Engine
Coût	Gratuit, licence MIT, aucune redevance	Offres gratuite et payantes selon conditions	Gratuit avec redevance au-delà d’un seuil de revenus
Langage	GDScript, C#	C#	C++, Blueprints (visuel)
Point fort	2D, légèreté, simplicité	Mobile, écosystème de ressources	3D haut de gamme, rendu réaliste
Poids de l’éditeur	Très léger	Lourd	Très lourd
Profil idéal	Débutants, indépendants, projets 2D	Studios mobiles, projets variés	Projets 3D ambitieux

Les conditions commerciales de Unity et d’Unreal évoluent : consultez leurs pages officielles. Pour un premier jeu, Godot offre le meilleur rapport entre simplicité et possibilités. Côté graphismes, des logiciels vectoriels comme Inkscape ou Illustrator sont parfaits pour dessiner sprites et décors, et DaVinci Resolve vous aidera à monter la bande-annonce de votre jeu.

Comment apprendre Godot efficacement ?

Voici le parcours que nous recommandons :

1. Découverte : installation, interface, nœuds, scènes, raccourcis.
2. GDScript : variables, conditions, boucles, tableaux, dictionnaires, fonctions, signaux, sur de petits scripts.
3. Premier jeu très simple : un jeu d’esquive ou de course vue de dessus, avec apparition aléatoire d’obstacles, score et écran de fin.
4. Jeu de plateforme : gravité, saut, animations, tuiles, ennemis, vie, menus et sons.
5. 3D : une scène simple, puis un petit jeu comme un labyrinthe.
6. Toujours : terminer et exporter chaque projet, même modeste.

Pour suivre ce parcours avec trois projets complets, la formation Godot pour développer un jeu vidéo de A à Z d’EspritAcadémique totalise près de 15 heures de vidéos, sans prérequis. Elle couvre notamment :

• l’installation, l’interface, la hiérarchie des nœuds, la physique et le débogage ;
• toutes les bases du GDScript, des variables aux énumérations et à la portée ;
• un jeu de course 2D avec apparition aléatoire, collisions, shader de route et export ;
• un jeu de plateforme complet : animations, tuiles, parallaxe, ennemis, barre de vie, menus et audio ;
• les fondamentaux de la 3D puis un labyrinthe avec personnage à la première personne et GridMap ;
• le code source de chaque projet.

En résumé

Godot est un moteur de jeu gratuit, léger et complet, idéal pour créer un premier jeu vidéo en 2D puis en 3D. Pensez en nœuds et en scènes réutilisables, programmez en GDScript avec _physics_process et move_and_slide, faites communiquer vos éléments par signaux et testez chaque scène seule. En terminant de petits projets jusqu’à l’export, vous progresserez bien plus vite qu’en visant d’emblée un jeu ambitieux.