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

> Créez votre premier jeu vidéo avec Godot : nœuds, scènes, GDScript, personnage 2D, collisions, signaux, interface, son et export, avec du code commenté.

- URL : https://guides-numeriques.fr/developpement/godot-jeu-video/
- Thématique : Développement web & mobile
- Mis à jour : 2026-09-26
- Formation associée : [Apprendre Godot : Maîtriser et développer un jeu vidéo de A à Z](https://espritacademique.com/formations/apprendre-godot-maitriser-et-developper-un-jeu-video-de-a-a-z/)

## L'essentiel

- Godot est un moteur de jeu vidéo gratuit et open source, distribué sous licence MIT, qui permet de créer des jeux 2D et 3D sans frais ni redevance.
- Un jeu Godot est un assemblage de nœuds organisés en scènes réutilisables : un personnage, un ennemi ou un niveau sont chacun une scène.
- GDScript, le langage intégré, a une syntaxe proche de Python fondée sur l'indentation, ce qui le rend accessible aux débutants.
- Les signaux permettent aux nœuds de communiquer sans dépendre les uns des autres : un bouton pressé, une collision ou un minuteur écoulé émettent un signal.
- Un jeu Godot s'exporte vers Windows, macOS, Linux, Android, iOS et le web après installation des modèles d'exportation.

**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](https://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](https://guides-numeriques.fr/developpement/flutter-application-mobile/) 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.


**Schéma — Créer un jeu de plateforme 2D avec Godot en 6 étapes**

1. **Créer le projet** : Nouveau projet, actions gauche, droite, sauter
2. **Scène du joueur** : CharacterBody2D, AnimatedSprite2D, Camera2D
3. **Script de déplacement** : GDScript : gravité, saut, move_and_slide()
4. **Construire le niveau** : TileSet avec collisions, joueur instancié
5. **Pièces et signaux** : Area2D connecté au signal body_entered
6. **Instancier par le code** : Timer et apparition d'ennemis ou d'obstacles


### É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 :

```gdscript
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 :

```gdscript
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 :

```gdscript
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.

> **Formation recommandée** : [Apprendre Godot : Maîtriser et développer un jeu vidéo de A à Z](https://espritacademique.com/formations/apprendre-godot-maitriser-et-developper-un-jeu-video-de-a-a-z/) — 14h45 de vidéo, 89 €.

## 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 :

```gdscript
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 :

```gdscript
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](https://guides-numeriques.fr/design/inkscape/) ou [Illustrator](https://guides-numeriques.fr/design/illustrator-dessin-vectoriel/) sont parfaits pour dessiner sprites et décors, et [DaVinci Resolve](https://guides-numeriques.fr/design/davinci-resolve/) vous aidera à monter la bande-annonce de votre jeu.


**Schéma — Godot, Unity ou Unreal Engine : quel moteur choisir ?**

| Godot | Unity | Unreal Engine |
|---|---|---|
| Gratuit, licence MIT | Offres gratuite et payantes | Gratuit, redevance selon revenus |
| GDScript ou C# | Langage C# | C++ et Blueprints |
| 2D native, éditeur très léger | Mobile, écosystème de ressources | 3D haut de gamme, très lourd |


## 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](https://espritacademique.com/formations/apprendre-godot-maitriser-et-developper-un-jeu-video-de-a-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.

## Sources et documentation officielle

- [Documentation de Godot Engine (4.x) en français (Godot Engine)](https://docs.godotengine.org/fr/4.x/)
- [Nœuds et scènes (documentation Godot Engine)](https://docs.godotengine.org/fr/4.x/getting_started/step_by_step/nodes_and_scenes.html)
- [Référence GDScript (documentation Godot Engine)](https://docs.godotengine.org/fr/4.x/tutorials/scripting/gdscript/gdscript_basics.html)
- [Votre premier jeu 2D (documentation Godot Engine)](https://docs.godotengine.org/fr/4.x/getting_started/first_2d_game/index.html)

## Questions fréquentes

### Godot est-il vraiment gratuit ?

Oui. Godot est un logiciel libre distribué sous licence MIT : vous pouvez l'utiliser, le modifier et vendre les jeux créés avec, sans payer de licence ni de redevance sur vos revenus. Le moteur est développé par une communauté et soutenu par des dons. Seules les plateformes de distribution (boutiques d'applications, consoles) peuvent imposer leurs propres conditions.

### Faut-il savoir programmer pour utiliser Godot ?

Non, mais il faudra apprendre. Godot s'utilise avec du code, principalement en GDScript, un langage pensé pour les débutants, avec une syntaxe proche de Python. Les premiers scripts (déplacer un personnage, détecter une collision) tiennent en quelques lignes. On apprend donc la programmation en même temps que le moteur, avec un résultat visible immédiatement.

### Quelle différence entre Godot et Unity ?

Godot est gratuit, open source, léger et très apprécié pour la 2D, avec son propre langage GDScript et une prise en charge de C#. Unity est un moteur commercial, très répandu dans l'industrie et le jeu mobile, avec un vaste magasin de ressources et le C# comme langage. Pour débuter et pour les projets indépendants, Godot est un excellent choix.

### Peut-on faire de la 3D avec Godot ?

Oui. Godot dispose d'un moteur 3D complet : nœuds 3D, caméras, lumières, matériaux physiques, environnement, physique et GridMap pour construire des niveaux modulaires. Il convient très bien aux jeux 3D indépendants, comme un labyrinthe, un jeu d'exploration ou un jeu à la première personne. Pour des productions 3D de très grande envergure, d'autres moteurs restent plus répandus.

### Combien de temps faut-il pour créer son premier jeu avec Godot ?

Un petit jeu 2D simple, comme un jeu d'esquive ou de course vue de dessus, peut être réalisé en quelques jours en suivant un tutoriel guidé. Un jeu de plateforme complet avec plusieurs niveaux, ennemis, interface et sons demande plutôt quelques semaines. L'important est de terminer de petits projets avant de se lancer dans un grand.

### Quelle version de Godot choisir pour débuter ?

Choisissez la dernière version stable de la branche 4, disponible sur le site officiel. Évitez Godot 3 pour un nouveau projet : de nombreux noms de nœuds et fonctions ont changé entre les deux versions, et les tutoriels récents utilisent Godot 4. Vérifiez toujours la version utilisée par un tutoriel avant de le suivre.