GDScript Cheat Sheet
Ultimo aggiornamento
Basi e output
Uno script estende un tipo di nodo, e Godot chiama le sue funzioni al posto tuo.
| Operazione | Sintassi |
|---|---|
| Collegare lo script a un tipo di nodo | extends Node |
| Codice eseguito all'avvio del nodo | func _ready() -> void:
print("Hello, World!") |
| Stampare valori senza separatore | print("HP: ", hp) |
| Stampare valori separati da spazi | prints("a", "b", 3) |
| Commento | # This is a comment |
| Commento di documentazione | ## Shown in the editor's help |
| Stringa su più righe | var text := """Line one
Line two""" |
| Segnalare un errore | push_error("Health is negative") |
| Segnalare un avviso | push_warning("Old save file") |
Variabili, costanti e tipi
I tipi sono facoltativi. Aggiungili per avere controlli nell'editor, autocompletamento e codice più veloce.
| Operazione | Sintassi |
|---|---|
| Variabile (tipo dinamico) | var score = 0 |
| Variabile con tipo statico | var speed: float = 200.0 |
| Dedurre il tipo statico | var lives := 3 |
| Costante | const MAX_HP = 100 |
| Enum | enum State { IDLE, RUN, JUMP } |
| Usare un valore di un enum | var state: State = State.IDLE |
| Valori di vettore e colore | var pos := Vector2(10, 20)
var tint := Color(1, 0, 0) |
| Riferimento a oggetto vuoto | var target: Node = null |
| Convertire in testo, int o float | str(42), int("42"), float("3.5") |
| Da float a int (tronca i decimali) | int(3.9) # 3 |
| Controllare un tipo | value is int, node is Sprite2D |
| Convertire in un tipo (cast) | var sprite := node as Sprite2D |
Operatori
La matematica di sempre, più parole inglesi per la logica.
| Operazione | Sintassi |
|---|---|
| Somma, sottrazione, moltiplicazione, divisione | a + b, a - b, a * b, a / b |
| Divisione intera (int / int) | 7 / 2 # 3 |
| Resto | 7 % 3, fmod(7.5, 2.0) |
| Potenza | 2 ** 10 # 1024 |
| Assegnazione composta | x += 1, x -= 1, x *= 2, x /= 2 |
| Confronto | ==, !=, <, >, <=, >= |
| Logica | a and b, a or b, not a |
| Logica (con simboli) | a && b, a || b, !a |
| If in linea | var label := "win" if score > 10 else "lose" |
| È in una collezione | "sword" in inventory |
| Operatori bit a bit | a & b, a | b, a ^ b, ~a, a << 1, a >> 1 |
Controllo del flusso
I blocchi si definiscono con l'indentazione, come in Python. Godot indenta con i tab per impostazione predefinita.
| Operazione | Sintassi |
|---|---|
| If, elif, else | if hp <= 0:
die()
elif hp < 20:
print("Low HP")
else:
print("OK") |
| If su una riga | if hp <= 0: die() |
| Ciclo su un intervallo | for i in range(5):
print(i) # 0 to 4 |
| Intervallo con inizio, fine e passo | for i in range(10, 0, -2):
print(i) # 10, 8, 6, 4, 2 |
| Ripetere n volte | for i in 3:
print(i) # 0, 1, 2 |
| Ciclo su un array | for item in items:
print(item) |
| Variabile di ciclo tipizzata (Godot 4.2+) | for n: String in names:
print(n.to_upper()) |
| Ciclo while | while hp > 0:
hp -= 10 |
| Uscire dal ciclo o saltare un passo | break, continue |
| Segnaposto per un blocco vuoto | pass |
Pattern matching (match)
match esegue il primo ramo il cui pattern corrisponde. Non c'è fallthrough.
| Operazione | Sintassi |
|---|---|
| Confrontare valori | match state:
State.IDLE:
print("idle")
State.RUN:
print("run") |
| Più valori in un ramo | match key:
"w", "up":
move_up() |
| Ramo predefinito (jolly) | match n:
0:
print("zero")
_:
print("other") |
| Associare il valore a un nome | match cmd:
"quit":
get_tree().quit()
var other:
print("Unknown: ", other) |
| Pattern di array | match pos:
[0, 0]:
print("origin")
[var x, 0]:
print("on the x axis at ", x) |
| Array con qualsiasi coda | match args:
["move", ..]:
print("move command") |
| Pattern di dizionario | match item:
{"type": "coin", "value": var v}:
gold += v |
| Condizione con when (Godot 4.4+) | match score:
var s when s >= 90:
print("A")
var s when s >= 75:
print("B")
_:
print("C") |
Funzioni e lambda
Anche le funzioni sono valori: puoi salvarle, passarle e associarvi degli argomenti.
| Operazione | Sintassi |
|---|---|
| Parametri e ritorno tipizzati | func add(a: int, b: int) -> int:
return a + b |
| Nessun valore di ritorno | func reset() -> void:
score = 0 |
| Argomento predefinito | func greet(who := "player") -> void:
print("Hi, ", who) |
| Funzione statica | static func double(x: int) -> int:
return x * 2 |
| Lambda su una riga | var square := func(x): return x * x |
| Chiamare un Callable | square.call(4) # 16 |
| Funzione come valore | var on_done := reset
on_done.call() |
| Associare argomenti | var add_ten := add.bind(10)
print(add_ten.call(5)) # 15 |
| Lambda su più righe | var greet_all := func(names: Array) -> void:
for n in names:
print("Hi, ", n) |
| Attendere un timer | await get_tree().create_timer(1.0).timeout |
| Attendere una coroutine | var data = await fetch_data() |
Stringhe
I metodi delle stringhe restituiscono una nuova stringa e non modificano mai l'originale.
| Operazione | Sintassi |
|---|---|
| Formattare con % | "%s has %d HP" % [name, hp] |
| Due decimali | "%.2f" % 3.14159 # "3.14" |
| Formattare con segnaposto con nome | "{a} vs {b}".format({"a": 1, "b": 2}) |
| Concatenare con + | "Score: " + str(score) |
| Lunghezza | text.length() |
| Maiuscolo o minuscolo | text.to_upper(), text.to_lower() |
| Dividere in parti | "a,b,c".split(",") # ["a", "b", "c"] |
| Unire le parti | ", ".join(["a", "b", "c"]) |
| Rimuovere gli spazi | " hi ".strip_edges() # "hi" |
| Sostituire testo | text.replace("cat", "dog") |
| Trovare una posizione | text.find("lo") # -1 if missing |
| Inizia o finisce con | text.begins_with("Hi"), text.ends_with("!") |
| Sottostringa | text.substr(0, 5) |
| Contiene | "ell" in "Hello" # true |
Array
Gli array crescono e si riducono. Un array tipizzato accetta solo il proprio tipo di elemento.
| Operazione | Sintassi |
|---|---|
| Letterale di array (tipi misti) | var items = [1, "two", 3.0] |
| Array tipizzato | var scores: Array[int] = [10, 20, 30] |
| Leggere per indice (i negativi contano dalla fine) | scores[0], scores[-1] |
| Aggiungere in fondo | scores.append(40), scores.push_back(40) |
| Inserire a un indice | scores.insert(0, 5) |
| Rimuovere e restituire l'ultimo | var last = scores.pop_back() |
| Rimuovere per valore o per indice | scores.erase(20), scores.remove_at(0) |
| Contiene, indice di | scores.has(30), scores.find(30) |
| Lunghezza, controllo se è vuoto | scores.size(), scores.is_empty() |
| Ordinare | scores.sort() |
| Ordinare con una regola tua | enemies.sort_custom(func(a, b): return a.hp < b.hp) |
| Map | scores.map(func(x): return x * 2) |
| Filter | scores.filter(func(x): return x > 15) |
| Reduce | scores.reduce(func(acc, x): return acc + x, 0) |
| Slice (fine esclusa) | scores.slice(1, 3) |
Dizionari
Coppie chiave e valore. Le chiavi possono essere di qualsiasi tipo; le stringhe sono le più comuni.
| Operazione | Sintassi |
|---|---|
| Letterale di dizionario | var stats = {"hp": 100, "mp": 30} |
| Dizionario tipizzato (Godot 4.4+) | var prices: Dictionary[String, int] = {"sword": 50} |
| Leggere o scrivere una chiave | stats["hp"], stats["xp"] = 50 |
| Leggere con un valore predefinito | stats.get("luck", 0) |
| Ha una chiave | stats.has("hp"), "hp" in stats |
| Rimuovere una chiave | stats.erase("mp") |
| Chiavi e valori | stats.keys(), stats.values() |
| Numero di voci | stats.size() |
| Unire un altro dizionario (true sovrascrive) | stats.merge({"luck": 5}), stats.merge(bonus, true) |
| Ciclo sulle chiavi | for key in stats:
print(key, " = ", stats[key]) |
Classi e annotazioni
Ogni script è una classe. Le annotazioni iniziano con @.
| Operazione | Sintassi |
|---|---|
| Dare alla classe un nome globale | class_name Player
extends CharacterBody2D |
| Costruttore | func _init(start_hp := 100) -> void:
hp = start_hp |
| Creare un'istanza | var p := Player.new() |
| Classe interna | class Item:
var name := ""
var price := 0 |
| Chiamare la versione del genitore di questo metodo | func _ready() -> void:
super()
print("child ready") |
| Chiamare un altro metodo del genitore | super.take_damage(10) |
| Variabile statica (Godot 4.1+) | static var count := 0 |
| Mostrare nell'Inspector | @export var speed := 300.0 |
| Mostrare con uno slider a intervallo | @export_range(0, 100) var volume := 50 |
| Ottenere un nodo figlio quando è pronto | @onready var sprite: Sprite2D = $Sprite2D |
| Setter e getter | var hp := 100:
set(value):
hp = clampi(value, 0, 100)
get:
return hp |
| Eseguire lo script nell'editor | @tool |
Segnali
I segnali sono di prima classe: dichiarali, poi emettili, collegali e attendili direttamente.
| Operazione | Sintassi |
|---|---|
| Dichiarare un segnale | signal died |
| Segnale con argomenti tipizzati | signal health_changed(old_hp: int, new_hp: int) |
| Emettere | died.emit() |
| Emettere con argomenti | health_changed.emit(100, 80) |
| Collegare a un metodo | player.died.connect(_on_player_died) |
| Collegare una lambda | button.pressed.connect(func(): print("Clicked")) |
| Passare argomenti extra | button.pressed.connect(_on_pressed.bind("start")) |
| Attivare una sola volta | timer.timeout.connect(_on_timeout, CONNECT_ONE_SHOT) |
| Scollegare | player.died.disconnect(_on_player_died) |
| Controllare un collegamento | player.died.is_connected(_on_player_died) |
| Attendere un segnale | await player.died |
Nodi e ciclo di vita
I callback che Godot chiama sul tuo nodo e le chiamate che fai sull'albero della scena.
| Operazione | Sintassi |
|---|---|
| Oggetto creato (prima dell'albero) | func _init() -> void:
print("created") |
| Il nodo e i suoi figli sono pronti | func _ready() -> void:
print("ready") |
| A ogni frame | func _process(delta: float) -> void:
position.x += 100.0 * delta |
| A ogni tick della fisica | func _physics_process(delta: float) -> void:
velocity.y += 980.0 * delta
move_and_slide() |
| Input non usato dall'interfaccia | func _unhandled_input(event: InputEvent) -> void:
if event.is_action_pressed("jump"):
jump() |
| Ottenere un nodo tramite percorso | get_node("Sprite2D"), $Sprite2D |
| Percorso con spazi, nome univoco | $"UI/Health Bar", %HealthBar |
| Controllare un'azione di input | Input.is_action_pressed("move_right") |
| Creare un'istanza di una scena | var enemy := preload("res://enemy.tscn").instantiate()
add_child(enemy) |
| Eliminare un nodo in modo sicuro | queue_free() |
| Genitore e figli | get_parent(), get_children() |
| Cambiare scena | get_tree().change_scene_to_file("res://main.tscn") |
La sintassi di GDScript che ti serve mentre crei un gioco in Godot, in una sola pagina. Questa cheat sheet di GDScript è un riferimento rapido per Godot 4: variabili e tipi statici, operatori, controllo del flusso e match, funzioni e lambda, stringhe, array e dizionari, classi, segnali e i callback dei nodi che Godot esegue a ogni frame.
Qui è tutto sintassi di Godot 4, quindi troverai @export, @onready, died.emit() e await al posto delle forme di Godot 3. Copia quello che ti serve nel tuo script oppure prova i frammenti del linguaggio dal vivo nel playground GDScript: mettili dentro _ready() ed eseguili nel browser, senza installare Godot.
Domande frequenti sulla cheat sheet di GDScript
Questa cheat sheet di GDScript è gratuita?
Sì. Questa cheat sheet di GDScript è completamente gratuita e non richiede registrazione. Salvala nei preferiti e torna quando ti serve la sintassi esatta di un segnale, di un pattern di match o di un metodo degli array.
Questa cheat sheet è per Godot 4 o Godot 3?
Godot 4. Le due versioni differiscono in punti che rompono il codice copiato: Godot 4 usa le annotazioni
@export e @onready al posto delle parole chiave export e onready, died.emit() e died.connect(callable) al posto di emit_signal("died") e del connect basato su stringhe, await al posto di yield, e super() al posto di .method(). Le righe segnate con 4.1+, 4.2+ o 4.4+ richiedono almeno quella versione di Godot.Qual è la differenza tra = e := in GDScript?
var x = 5 crea una variabile dinamica che in seguito può contenere qualsiasi tipo. var x := 5 deduce il tipo dal valore (qui int) e lo blocca, quindi assegnarle poi una stringa dà errore. var x: int = 5 indica il tipo in modo esplicito. I tipi statici ti danno errori nell'editor, un autocompletamento migliore e codice più veloce.Come funzionano i segnali in GDScript?
Dichiara un segnale con
signal died, invialo con died.emit() e reagisci da un altro nodo con player.died.connect(_on_player_died). Puoi collegare una lambda invece di un metodo, associare argomenti extra con .bind() oppure mettere in pausa una funzione finché il segnale non scatta con await player.died.GDScript è simile a Python?
All'apparenza sì: i blocchi si definiscono con l'indentazione e usa
for ... in, if/elif/else e parole inglesi come and, or e not. Ma GDScript è un linguaggio a sé, creato per Godot. Ha tipi statici facoltativi, segnali, annotazioni come @export e accesso diretto ai nodi con $.Posso esercitarmi con GDScript online?
Sì. Apri il playground GDScript per eseguire i frammenti di questa cheat sheet nel browser: il playground collega il tuo script a un nodo, quindi il codice dentro
_ready() viene eseguito una volta. Quando vuoi un percorso strutturato, il corso interattivo gratuito di GDScript di Coddy ti porta passo dopo passo dalle variabili e funzioni alle classi e ai segnali.Risorse correlate
Altre cheat sheet
