GDScript Cheat Sheet: ściąga z GDScript
Ostatnia aktualizacja
Podstawy i wypisywanie
Skrypt rozszerza typ węzła, a Godot sam wywołuje jego funkcje.
| Operacja | Składnia |
|---|---|
| Podłącz skrypt do typu węzła | extends Node |
| Kod uruchamiany przy starcie węzła | func _ready() -> void:
print("Hello, World!") |
| Wypisz wartości bez separatora | print("HP: ", hp) |
| Wypisz wartości oddzielone spacjami | prints("a", "b", 3) |
| Komentarz | # This is a comment |
| Komentarz dokumentacyjny | ## Shown in the editor's help |
| Łańcuch wielowierszowy | var text := """Line one
Line two""" |
| Zgłoś błąd | push_error("Health is negative") |
| Zgłoś ostrzeżenie | push_warning("Old save file") |
Zmienne, stałe i typy
Typy są opcjonalne. Dodaj je, by edytor sprawdzał kod, lepiej podpowiadał, a kod działał szybciej.
| Operacja | Składnia |
|---|---|
| Zmienna (typ dynamiczny) | var score = 0 |
| Zmienna z typem statycznym | var speed: float = 200.0 |
| Wywnioskuj typ statyczny | var lives := 3 |
| Stała | const MAX_HP = 100 |
| Enum | enum State { IDLE, RUN, JUMP } |
| Użyj wartości enuma | var state: State = State.IDLE |
| Wektory i kolory | var pos := Vector2(10, 20)
var tint := Color(1, 0, 0) |
| Pusta referencja do obiektu | var target: Node = null |
| Konwersja na tekst, int lub float | str(42), int("42"), float("3.5") |
| Float na int (obcina część dziesiętną) | int(3.9) # 3 |
| Sprawdź typ | value is int, node is Sprite2D |
| Rzutuj na typ | var sprite := node as Sprite2D |
Operatory
Znajoma matematyka, a do logiki angielskie słowa.
| Operacja | Składnia |
|---|---|
| Dodawanie, odejmowanie, mnożenie, dzielenie | a + b, a - b, a * b, a / b |
| Dzielenie całkowite (int / int) | 7 / 2 # 3 |
| Reszta z dzielenia | 7 % 3, fmod(7.5, 2.0) |
| Potęga | 2 ** 10 # 1024 |
| Przypisanie złożone | x += 1, x -= 1, x *= 2, x /= 2 |
| Porównanie | ==, !=, <, >, <=, >= |
| Logika | a and b, a or b, not a |
| Logika (zapis symboliczny) | a && b, a || b, !a |
| If w jednej linii (wyrażenie) | var label := "win" if score > 10 else "lose" |
| Czy jest w kolekcji | "sword" in inventory |
| Operacje bitowe | a & b, a | b, a ^ b, ~a, a << 1, a >> 1 |
Sterowanie przepływem
Bloki wyznacza wcięcie, jak w Pythonie. Godot domyślnie wcina tabulatorami.
| Operacja | Składnia |
|---|---|
| If, elif, else | if hp <= 0:
die()
elif hp < 20:
print("Low HP")
else:
print("OK") |
| If w jednej linii | if hp <= 0: die() |
| Pętla po zakresie | for i in range(5):
print(i) # 0 to 4 |
| Zakres z początkiem, końcem i krokiem | for i in range(10, 0, -2):
print(i) # 10, 8, 6, 4, 2 |
| Powtórz n razy | for i in 3:
print(i) # 0, 1, 2 |
| Pętla po tablicy | for item in items:
print(item) |
| Typowana zmienna pętli (Godot 4.2+) | for n: String in names:
print(n.to_upper()) |
| Pętla while | while hp > 0:
hp -= 10 |
| Wyjdź z pętli lub pomiń krok | break, continue |
| Pusty blok (placeholder) | pass |
Dopasowanie wzorców (match)
match wykonuje pierwszą gałąź, której wzorzec pasuje. Nie ma przechodzenia do kolejnej (fallthrough).
| Operacja | Składnia |
|---|---|
| Dopasuj wartości | match state:
State.IDLE:
print("idle")
State.RUN:
print("run") |
| Kilka wartości w jednej gałęzi | match key:
"w", "up":
move_up() |
| Gałąź domyślna (wildcard) | match n:
0:
print("zero")
_:
print("other") |
| Przypisz wartość do nazwy | match cmd:
"quit":
get_tree().quit()
var other:
print("Unknown: ", other) |
| Wzorzec tablicy | match pos:
[0, 0]:
print("origin")
[var x, 0]:
print("on the x axis at ", x) |
| Tablica z dowolną resztą | match args:
["move", ..]:
print("move command") |
| Wzorzec słownika | match item:
{"type": "coin", "value": var v}:
gold += v |
| Warunek z when (Godot 4.4+) | match score:
var s when s >= 90:
print("A")
var s when s >= 75:
print("B")
_:
print("C") |
Funkcje i lambdy
Funkcje też są wartościami: możesz je przechowywać, przekazywać i wiązać z nimi argumenty.
| Operacja | Składnia |
|---|---|
| Typowane parametry i wartość zwracana | func add(a: int, b: int) -> int:
return a + b |
| Brak wartości zwracanej | func reset() -> void:
score = 0 |
| Argument domyślny | func greet(who := "player") -> void:
print("Hi, ", who) |
| Funkcja statyczna | static func double(x: int) -> int:
return x * 2 |
| Lambda w jednej linii | var square := func(x): return x * x |
| Wywołaj Callable | square.call(4) # 16 |
| Funkcja jako wartość | var on_done := reset
on_done.call() |
| Wiązanie argumentów | var add_ten := add.bind(10)
print(add_ten.call(5)) # 15 |
| Lambda wielowierszowa | var greet_all := func(names: Array) -> void:
for n in names:
print("Hi, ", n) |
| Poczekaj na timer | await get_tree().create_timer(1.0).timeout |
| Poczekaj na korutynę | var data = await fetch_data() |
Łańcuchy
Metody łańcuchów zwracają nowy łańcuch i nigdy nie zmieniają oryginału.
| Operacja | Składnia |
|---|---|
| Formatowanie z % | "%s has %d HP" % [name, hp] |
| Dwa miejsca po przecinku | "%.2f" % 3.14159 # "3.14" |
| Formatowanie z nazwanymi placeholderami | "{a} vs {b}".format({"a": 1, "b": 2}) |
| Łączenie przez + | "Score: " + str(score) |
| Długość | text.length() |
| Wielkie lub małe litery | text.to_upper(), text.to_lower() |
| Podziel na części | "a,b,c".split(",") # ["a", "b", "c"] |
| Połącz części | ", ".join(["a", "b", "c"]) |
| Usuń białe znaki | " hi ".strip_edges() # "hi" |
| Zamień tekst | text.replace("cat", "dog") |
| Znajdź pozycję | text.find("lo") # -1 if missing |
| Zaczyna się lub kończy na | text.begins_with("Hi"), text.ends_with("!") |
| Podłańcuch | text.substr(0, 5) |
| Zawiera | "ell" in "Hello" # true |
Tablice
Tablice rosną i się kurczą. Tablica typowana przyjmuje tylko swój typ elementów.
| Operacja | Składnia |
|---|---|
| Literał tablicy (różne typy) | var items = [1, "two", 3.0] |
| Tablica typowana | var scores: Array[int] = [10, 20, 30] |
| Odczyt po indeksie (ujemny liczy od końca) | scores[0], scores[-1] |
| Dodaj na końcu | scores.append(40), scores.push_back(40) |
| Wstaw pod indeksem | scores.insert(0, 5) |
| Usuń i zwróć ostatni | var last = scores.pop_back() |
| Usuń po wartości lub po indeksie | scores.erase(20), scores.remove_at(0) |
| Zawiera, indeks elementu | scores.has(30), scores.find(30) |
| Długość, sprawdzenie pustości | scores.size(), scores.is_empty() |
| Sortuj | scores.sort() |
| Sortuj według własnej reguły | 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) |
| Wycinek (bez końca) | scores.slice(1, 3) |
Słowniki
Pary klucz i wartość. Klucze mogą mieć dowolny typ; najczęściej są to łańcuchy.
| Operacja | Składnia |
|---|---|
| Literał słownika | var stats = {"hp": 100, "mp": 30} |
| Słownik typowany (Godot 4.4+) | var prices: Dictionary[String, int] = {"sword": 50} |
| Odczyt lub zapis klucza | stats["hp"], stats["xp"] = 50 |
| Odczyt z wartością domyślną | stats.get("luck", 0) |
| Czy ma klucz | stats.has("hp"), "hp" in stats |
| Usuń klucz | stats.erase("mp") |
| Klucze i wartości | stats.keys(), stats.values() |
| Liczba wpisów | stats.size() |
| Scal inny słownik (true nadpisuje) | stats.merge({"luck": 5}), stats.merge(bonus, true) |
| Pętla po kluczach | for key in stats:
print(key, " = ", stats[key]) |
Klasy i adnotacje
Każdy skrypt jest klasą. Adnotacje zaczynają się od @.
| Operacja | Składnia |
|---|---|
| Nadaj klasie globalną nazwę | class_name Player
extends CharacterBody2D |
| Konstruktor | func _init(start_hp := 100) -> void:
hp = start_hp |
| Utwórz instancję | var p := Player.new() |
| Klasa wewnętrzna | class Item:
var name := ""
var price := 0 |
| Wywołaj wersję tej metody z klasy nadrzędnej | func _ready() -> void:
super()
print("child ready") |
| Wywołaj inną metodę klasy nadrzędnej | super.take_damage(10) |
| Zmienna statyczna (Godot 4.1+) | static var count := 0 |
| Pokaż w Inspektorze | @export var speed := 300.0 |
| Pokaż z suwakiem i zakresem | @export_range(0, 100) var volume := 50 |
| Pobierz węzeł potomny, gdy jest gotowy | @onready var sprite: Sprite2D = $Sprite2D |
| Setter i getter | var hp := 100:
set(value):
hp = clampi(value, 0, 100)
get:
return hp |
| Uruchamiaj skrypt w edytorze | @tool |
Sygnały
Sygnały są pełnoprawnymi obiektami: zadeklaruj je, a potem emituj, podłączaj i czekaj na nie bezpośrednio.
| Operacja | Składnia |
|---|---|
| Zadeklaruj sygnał | signal died |
| Sygnał z typowanymi argumentami | signal health_changed(old_hp: int, new_hp: int) |
| Emituj | died.emit() |
| Emituj z argumentami | health_changed.emit(100, 80) |
| Podłącz do metody | player.died.connect(_on_player_died) |
| Podłącz lambdę | button.pressed.connect(func(): print("Clicked")) |
| Przekaż dodatkowe argumenty | button.pressed.connect(_on_pressed.bind("start")) |
| Wywołaj tylko raz | timer.timeout.connect(_on_timeout, CONNECT_ONE_SHOT) |
| Odłącz | player.died.disconnect(_on_player_died) |
| Sprawdź połączenie | player.died.is_connected(_on_player_died) |
| Poczekaj na sygnał | await player.died |
Węzły i cykl życia
Callbacki, które Godot wywołuje na twoim węźle, i wywołania, które wykonujesz na drzewie sceny.
| Operacja | Składnia |
|---|---|
| Obiekt utworzony (przed drzewem) | func _init() -> void:
print("created") |
| Węzeł i jego dzieci są gotowe | func _ready() -> void:
print("ready") |
| W każdej klatce | func _process(delta: float) -> void:
position.x += 100.0 * delta |
| W każdym takcie fizyki | func _physics_process(delta: float) -> void:
velocity.y += 980.0 * delta
move_and_slide() |
| Wejście nieużyte przez UI | func _unhandled_input(event: InputEvent) -> void:
if event.is_action_pressed("jump"):
jump() |
| Pobierz węzeł po ścieżce | get_node("Sprite2D"), $Sprite2D |
| Ścieżka ze spacjami, unikalna nazwa | $"UI/Health Bar", %HealthBar |
| Sprawdź akcję wejścia | Input.is_action_pressed("move_right") |
| Utwórz instancję sceny | var enemy := preload("res://enemy.tscn").instantiate()
add_child(enemy) |
| Bezpiecznie usuń węzeł | queue_free() |
| Rodzic i dzieci | get_parent(), get_children() |
| Zmień scenę | get_tree().change_scene_to_file("res://main.tscn") |
Składnia GDScript, po którą sięgasz podczas tworzenia gry w Godot, na jednej stronie. Ten GDScript cheat sheet to szybka ściąga dla Godot 4: zmienne i typy statyczne, operatory, sterowanie przepływem i match, funkcje i lambdy, łańcuchy, tablice i słowniki, klasy, sygnały oraz callbacki węzłów, które Godot uruchamia w każdej klatce.
Wszystko tutaj to składnia Godot 4, więc zobaczysz @export, @onready, died.emit() i await zamiast form z Godot 3. Skopiuj to, czego potrzebujesz, do swojego skryptu albo uruchom fragmenty języka w edytorze online GDScript: umieść je w _ready() i uruchom w przeglądarce, bez instalowania Godot.
GDScript cheat sheet: najczęstsze pytania
Czy ta ściąga z GDScript jest darmowa?
Tak. Ta ściąga z GDScript jest całkowicie darmowa i nie wymaga rejestracji. Dodaj ją do zakładek i wracaj, gdy potrzebujesz dokładnej składni sygnału, wzorca match albo metody tablicy.
Czy ta ściąga jest dla Godot 4 czy Godot 3?
Dla Godot 4. Obie wersje różnią się w sposób, który psuje skopiowany kod: Godot 4 używa adnotacji
@export i @onready zamiast słów kluczowych export i onready, died.emit() i died.connect(callable) zamiast emit_signal("died") i connect opartego na łańcuchach, await zamiast yield oraz super() zamiast .method(). Wiersze oznaczone 4.1+, 4.2+ lub 4.4+ wymagają co najmniej tej wersji Godot.Jaka jest różnica między = a := w GDScript?
var x = 5 tworzy zmienną dynamiczną, która później może przechowywać dowolny typ. var x := 5 wnioskuje typ z wartości (tutaj int) i go blokuje, więc późniejsze przypisanie łańcucha to błąd. var x: int = 5 podaje typ jawnie. Typy statyczne dają błędy w edytorze, lepsze podpowiedzi i szybszy kod.Jak działają sygnały w GDScript?
Zadeklaruj sygnał przez
signal died, wyślij go przez died.emit() i reaguj na niego w innym węźle przez player.died.connect(_on_player_died). Zamiast metody możesz podłączyć lambdę, związać dodatkowe argumenty przez .bind() albo wstrzymać funkcję do momentu wywołania sygnału przez await player.died.Czy GDScript jest podobny do Pythona?
Wygląda podobnie: bloki wyznacza wcięcie, a język używa
for ... in, if/elif/else i angielskich słów, takich jak and, or i not. Ale GDScript to osobny język, stworzony dla Godot. Ma opcjonalne typy statyczne, sygnały, adnotacje takie jak @export i bezpośredni dostęp do węzłów przez $.Czy mogę ćwiczyć GDScript online?
Tak. Otwórz edytor online GDScript, aby uruchamiać fragmenty z tej ściągi w przeglądarce: edytor podłącza twój skrypt do węzła, więc kod w
_ready() uruchamia się raz. Jeśli chcesz uczyć się po kolei, darmowy interaktywny kurs GDScript w Coddy krok po kroku prowadzi od zmiennych i funkcji do klas i sygnałów.Powiązane materiały
Więcej ściąg
