Aide-mémoire GDScript
Dernière mise à jour
Bases et affichage
Un script étend un type de nœud, et Godot appelle ses fonctions pour vous.
| Opération | Syntaxe |
|---|---|
| Attacher le script à un type de nœud | extends Node |
| Code exécuté au démarrage du nœud | func _ready() -> void:
print("Hello, World!") |
| Afficher des valeurs sans séparateur | print("HP: ", hp) |
| Afficher des valeurs séparées par des espaces | prints("a", "b", 3) |
| Commentaire | # This is a comment |
| Commentaire de documentation | ## Shown in the editor's help |
| Chaîne multiligne | var text := """Line one
Line two""" |
| Signaler une erreur | push_error("Health is negative") |
| Signaler un avertissement | push_warning("Old save file") |
Variables, constantes et types
Les types sont facultatifs. Ajoutez-les pour les vérifications de l'éditeur, l'autocomplétion et un code plus rapide.
| Opération | Syntaxe |
|---|---|
| Variable (type dynamique) | var score = 0 |
| Variable avec un type statique | var speed: float = 200.0 |
| Déduire le type statique | var lives := 3 |
| Constante | const MAX_HP = 100 |
| Énumération | enum State { IDLE, RUN, JUMP } |
| Utiliser une valeur d'énumération | var state: State = State.IDLE |
| Vecteurs et couleurs | var pos := Vector2(10, 20)
var tint := Color(1, 0, 0) |
| Référence d'objet vide | var target: Node = null |
| Convertir en texte, int ou float | str(42), int("42"), float("3.5") |
| Float vers int (supprime les décimales) | int(3.9) # 3 |
| Vérifier un type | value is int, node is Sprite2D |
| Convertir vers un type (cast) | var sprite := node as Sprite2D |
Opérateurs
Les maths habituelles, plus des mots anglais pour la logique.
| Opération | Syntaxe |
|---|---|
| Addition, soustraction, multiplication, division | a + b, a - b, a * b, a / b |
| Division entière (int / int) | 7 / 2 # 3 |
| Reste | 7 % 3, fmod(7.5, 2.0) |
| Puissance | 2 ** 10 # 1024 |
| Affectation composée | x += 1, x -= 1, x *= 2, x /= 2 |
| Comparaison | ==, !=, <, >, <=, >= |
| Logique | a and b, a or b, not a |
| Logique (forme symbolique) | a && b, a || b, !a |
| If en ligne | var label := "win" if score > 10 else "lose" |
| Présence dans une collection | "sword" in inventory |
| Opérations bit à bit | a & b, a | b, a ^ b, ~a, a << 1, a >> 1 |
Contrôle de flux
Les blocs sont définis par l'indentation, comme en Python. Godot indente avec des tabulations par défaut.
| Opération | Syntaxe |
|---|---|
| If, elif, else | if hp <= 0:
die()
elif hp < 20:
print("Low HP")
else:
print("OK") |
| If sur une ligne | if hp <= 0: die() |
| Boucler sur un intervalle | for i in range(5):
print(i) # 0 to 4 |
| Intervalle avec début, fin et pas | for i in range(10, 0, -2):
print(i) # 10, 8, 6, 4, 2 |
| Répéter n fois | for i in 3:
print(i) # 0, 1, 2 |
| Boucler sur un tableau | for item in items:
print(item) |
| Variable de boucle typée (Godot 4.2+) | for n: String in names:
print(n.to_upper()) |
| Boucle while | while hp > 0:
hp -= 10 |
| Quitter la boucle ou sauter une itération | break, continue |
| Bloc vide (placeholder) | pass |
Filtrage par motif (match)
match exécute la première branche dont le motif correspond. Il n'y a pas de fallthrough.
| Opération | Syntaxe |
|---|---|
| Comparer des valeurs | match state:
State.IDLE:
print("idle")
State.RUN:
print("run") |
| Plusieurs valeurs dans une branche | match key:
"w", "up":
move_up() |
| Branche par défaut (joker) | match n:
0:
print("zero")
_:
print("other") |
| Lier la valeur à un nom | match cmd:
"quit":
get_tree().quit()
var other:
print("Unknown: ", other) |
| Motif de tableau | match pos:
[0, 0]:
print("origin")
[var x, 0]:
print("on the x axis at ", x) |
| Tableau avec une fin quelconque | match args:
["move", ..]:
print("move command") |
| Motif de dictionnaire | match item:
{"type": "coin", "value": var v}:
gold += v |
| Condition avec when (Godot 4.4+) | match score:
var s when s >= 90:
print("A")
var s when s >= 75:
print("B")
_:
print("C") |
Fonctions et lambdas
Les fonctions sont aussi des valeurs : stockez-les, passez-les et liez-leur des arguments.
| Opération | Syntaxe |
|---|---|
| Paramètres et retour typés | func add(a: int, b: int) -> int:
return a + b |
| Aucune valeur de retour | func reset() -> void:
score = 0 |
| Argument par défaut | func greet(who := "player") -> void:
print("Hi, ", who) |
| Fonction statique | static func double(x: int) -> int:
return x * 2 |
| Lambda sur une ligne | var square := func(x): return x * x |
| Appeler un Callable | square.call(4) # 16 |
| Fonction comme valeur | var on_done := reset
on_done.call() |
| Lier des arguments | var add_ten := add.bind(10)
print(add_ten.call(5)) # 15 |
| Lambda multiligne | var greet_all := func(names: Array) -> void:
for n in names:
print("Hi, ", n) |
| Attendre un timer | await get_tree().create_timer(1.0).timeout |
| Attendre une coroutine | var data = await fetch_data() |
Chaînes
Les méthodes de chaîne renvoient une nouvelle chaîne et ne modifient jamais l'originale.
| Opération | Syntaxe |
|---|---|
| Formater avec % | "%s has %d HP" % [name, hp] |
| Deux décimales | "%.2f" % 3.14159 # "3.14" |
| Formater avec des placeholders nommés | "{a} vs {b}".format({"a": 1, "b": 2}) |
| Concaténer avec + | "Score: " + str(score) |
| Longueur | text.length() |
| Majuscules ou minuscules | text.to_upper(), text.to_lower() |
| Découper en parties | "a,b,c".split(",") # ["a", "b", "c"] |
| Joindre des parties | ", ".join(["a", "b", "c"]) |
| Supprimer les espaces | " hi ".strip_edges() # "hi" |
| Remplacer du texte | text.replace("cat", "dog") |
| Trouver une position | text.find("lo") # -1 if missing |
| Commence ou finit par | text.begins_with("Hi"), text.ends_with("!") |
| Sous-chaîne | text.substr(0, 5) |
| Contient | "ell" in "Hello" # true |
Tableaux
Les tableaux s'agrandissent et rétrécissent. Un tableau typé n'accepte que son type d'élément.
| Opération | Syntaxe |
|---|---|
| Littéral de tableau (types mixtes) | var items = [1, "two", 3.0] |
| Tableau typé | var scores: Array[int] = [10, 20, 30] |
| Lire par indice (négatif = depuis la fin) | scores[0], scores[-1] |
| Ajouter à la fin | scores.append(40), scores.push_back(40) |
| Insérer à un indice | scores.insert(0, 5) |
| Retirer et renvoyer le dernier | var last = scores.pop_back() |
| Retirer par valeur ou par indice | scores.erase(20), scores.remove_at(0) |
| Contient, indice de | scores.has(30), scores.find(30) |
| Longueur, test de vide | scores.size(), scores.is_empty() |
| Trier | scores.sort() |
| Trier selon sa propre règle | enemies.sort_custom(func(a, b): return a.hp < b.hp) |
| Map | scores.map(func(x): return x * 2) |
| Filtrer | scores.filter(func(x): return x > 15) |
| Reduce | scores.reduce(func(acc, x): return acc + x, 0) |
| Tranche (fin exclue) | scores.slice(1, 3) |
Dictionnaires
Des paires clé et valeur. Les clés peuvent être de n'importe quel type ; les chaînes sont les plus courantes.
| Opération | Syntaxe |
|---|---|
| Littéral de dictionnaire | var stats = {"hp": 100, "mp": 30} |
| Dictionnaire typé (Godot 4.4+) | var prices: Dictionary[String, int] = {"sword": 50} |
| Lire ou écrire une clé | stats["hp"], stats["xp"] = 50 |
| Lire avec une valeur par défaut | stats.get("luck", 0) |
| Contient une clé | stats.has("hp"), "hp" in stats |
| Supprimer une clé | stats.erase("mp") |
| Clés et valeurs | stats.keys(), stats.values() |
| Nombre d'entrées | stats.size() |
| Fusionner un autre dictionnaire (true écrase) | stats.merge({"luck": 5}), stats.merge(bonus, true) |
| Boucler sur les clés | for key in stats:
print(key, " = ", stats[key]) |
Classes et annotations
Chaque script est une classe. Les annotations commencent par @.
| Opération | Syntaxe |
|---|---|
| Donner un nom global à la classe | class_name Player
extends CharacterBody2D |
| Constructeur | func _init(start_hp := 100) -> void:
hp = start_hp |
| Créer une instance | var p := Player.new() |
| Classe interne | class Item:
var name := ""
var price := 0 |
| Appeler la version parente de cette méthode | func _ready() -> void:
super()
print("child ready") |
| Appeler une autre méthode parente | super.take_damage(10) |
| Variable statique (Godot 4.1+) | static var count := 0 |
| Afficher dans l'Inspecteur | @export var speed := 300.0 |
| Afficher avec un curseur | @export_range(0, 100) var volume := 50 |
| Récupérer un nœud enfant quand il est prêt | @onready var sprite: Sprite2D = $Sprite2D |
| Setter et getter | var hp := 100:
set(value):
hp = clampi(value, 0, 100)
get:
return hp |
| Exécuter le script dans l'éditeur | @tool |
Signaux
Les signaux sont des objets à part entière : déclarez-les, puis émettez-les, connectez-les et attendez-les directement.
| Opération | Syntaxe |
|---|---|
| Déclarer un signal | signal died |
| Signal avec arguments typés | signal health_changed(old_hp: int, new_hp: int) |
| Émettre | died.emit() |
| Émettre avec des arguments | health_changed.emit(100, 80) |
| Connecter à une méthode | player.died.connect(_on_player_died) |
| Connecter une lambda | button.pressed.connect(func(): print("Clicked")) |
| Passer des arguments supplémentaires | button.pressed.connect(_on_pressed.bind("start")) |
| Déclencher une seule fois | timer.timeout.connect(_on_timeout, CONNECT_ONE_SHOT) |
| Déconnecter | player.died.disconnect(_on_player_died) |
| Vérifier une connexion | player.died.is_connected(_on_player_died) |
| Attendre un signal | await player.died |
Nœuds et cycle de vie
Les callbacks que Godot appelle sur votre nœud, et les appels que vous faites sur l'arbre de scène.
| Opération | Syntaxe |
|---|---|
| Objet créé (avant l'arbre) | func _init() -> void:
print("created") |
| Le nœud et ses enfants sont prêts | func _ready() -> void:
print("ready") |
| À chaque image | func _process(delta: float) -> void:
position.x += 100.0 * delta |
| À chaque tick physique | func _physics_process(delta: float) -> void:
velocity.y += 980.0 * delta
move_and_slide() |
| Entrée non utilisée par l'UI | func _unhandled_input(event: InputEvent) -> void:
if event.is_action_pressed("jump"):
jump() |
| Récupérer un nœud par chemin | get_node("Sprite2D"), $Sprite2D |
| Chemin avec espaces, nom unique | $"UI/Health Bar", %HealthBar |
| Vérifier une action d'entrée | Input.is_action_pressed("move_right") |
| Instancier une scène | var enemy := preload("res://enemy.tscn").instantiate()
add_child(enemy) |
| Supprimer un nœud en toute sécurité | queue_free() |
| Parent et enfants | get_parent(), get_children() |
| Changer de scène | get_tree().change_scene_to_file("res://main.tscn") |
La syntaxe GDScript dont vous avez besoin pour créer un jeu Godot, sur une seule page. Cet aide-mémoire GDScript est une référence rapide pour Godot 4 : variables et types statiques, opérateurs, contrôle de flux et match, fonctions et lambdas, chaînes, tableaux et dictionnaires, classes, signaux, et les callbacks de nœud que Godot exécute à chaque image.
Tout ici est de la syntaxe Godot 4 : vous verrez donc @export, @onready, died.emit() et await plutôt que les formes de Godot 3. Copiez ce dont vous avez besoin dans votre script, ou essayez les extraits du langage en direct dans le playground GDScript : placez-les dans _ready() et exécutez-les dans votre navigateur, sans installer Godot.
FAQ de l'aide-mémoire GDScript
Cet aide-mémoire GDScript est-il gratuit ?
Oui. Cet aide-mémoire GDScript est entièrement gratuit, sans inscription. Ajoutez-le à vos favoris et revenez-y dès que vous avez besoin de la syntaxe exacte d'un signal, d'un motif match ou d'une méthode de tableau.
Cet aide-mémoire est-il pour Godot 4 ou Godot 3 ?
Godot 4. Les deux versions diffèrent sur des points qui cassent le code copié : Godot 4 utilise les annotations
@export et @onready au lieu des mots-clés export et onready, died.emit() et died.connect(callable) au lieu de emit_signal("died") et du connect basé sur des chaînes, await au lieu de yield, et super() au lieu de .method(). Les lignes marquées 4.1+, 4.2+ ou 4.4+ exigent au moins cette version de Godot.Quelle est la différence entre = et := en GDScript ?
var x = 5 crée une variable dynamique qui peut ensuite contenir n'importe quel type. var x := 5 déduit le type à partir de la valeur (ici int) et le fige : affecter une chaîne plus tard provoque une erreur. var x: int = 5 indique le type explicitement. Les types statiques vous donnent des erreurs dans l'éditeur, une meilleure autocomplétion et un code plus rapide.Comment fonctionnent les signaux en GDScript ?
Déclarez un signal avec
signal died, émettez-le avec died.emit() et réagissez-y depuis un autre nœud avec player.died.connect(_on_player_died). Vous pouvez connecter une lambda au lieu d'une méthode, lier des arguments supplémentaires avec .bind(), ou suspendre une fonction jusqu'à l'émission du signal avec await player.died.GDScript ressemble-t-il à Python ?
Il y ressemble : les blocs sont définis par l'indentation, et il utilise
for ... in, if/elif/else et des mots anglais comme and, or et not. Mais GDScript est un langage à part, conçu pour Godot. Il propose des types statiques facultatifs, des signaux, des annotations comme @export et un accès direct aux nœuds avec $.Puis-je pratiquer GDScript en ligne ?
Oui. Ouvrez le playground GDScript pour exécuter les extraits de cet aide-mémoire dans votre navigateur : le playground attache votre script à un nœud, donc le code placé dans
_ready() s'exécute une fois. Pour un apprentissage structuré, le cours GDScript interactif et gratuit de Coddy vous emmène pas à pas des variables et fonctions jusqu'aux classes et signaux.Ressources connexes
Plus d'aide-mémoires
