Befehlszeilen-Anleitung¶

Manche Entwickler lieben es, die Befehlszeile ausgiebig zu nutzen. Godot wurde dazu designt, für diese Nutzer auch nützlich zu sein, d.h. hier die Anleitung um vollumfänglich von der Befehlszeile aus zu arbeiten. Dadurch dass die Engine sich fast ausschließlich nur auf eigenen Code stützt und kaum externe Bibliotheken verwendet gehen die Initialisierungszeiten ziemlich schnell von statten, was sich als praktisch für diese Arbeitsweise herausstellt.

Bemerkung

Unter Windows und Linux können Sie eine Godot-Binärdatei in einem Terminal ausführen, indem Sie den relativen oder absoluten Pfad angeben.

Unter macOS ist der Prozess anders, da Godot in einem .app-Bundle enthalten ist (was ein Ordner ist, keine Datei). Um eine Godot-Binärdatei von einem Terminal unter macOS aus zu starten, müssen Sie mit cd in den Ordner wechseln, in dem sich das Godot-Anwendungspaket befindet, und dann Godot.app/Contents/MacOS/Godot gefolgt von beliebigen Kommandozeilenargumenten ausführen. Wenn Sie das Anwendungspaket Godot umbenannt haben, stellen Sie sicher, dass Sie diese Befehlszeile entsprechend ändern.

Kommandozeilenparameter¶

Allgemeine Eigenschaften

Befehl	Beschreibung
`-h`, `--help`, `/?`	Zeigt die Liste der Befehlszeilen-Optionen.
`--version`	Zeigt die Version.
`-v`, `--verbose`	Benutze den ausführlichen stdout Modus.
`--quiet`	Ruhiger Modus, unterdrückt stdout Nachrichten. Fehler werden immer noch angezeigt.

Ausführen Eigenschaften

Befehl	Beschreibung
`-e`, `--editor`	Starte den Editor anstelle der laufenden Szene (Tools müssen aktiviert sein).
`-p`, `--project-manager`	Starte die Projektverwaltung, selbst wenn ein Projekt automatisch erkannt wird (Tools muss aktiviert sein).
`-q`, `--quit`	Beende nach dem ersten Schleifendurchgang.
`-l <local>`, `--language <local>`	Verwenden Sie ein bestimmtes Gebietsschema (<locale> ist ein aus zwei Buchstaben bestehender Code). Weitere Informationen finden Sie unter Lokalisierung.
`--path <Verzeichnis>`	Der Pfad zu dem jeweiligen Projekt. (<directory> muss eine 'Projektname.godot' Datei enthalten).
`-u`, `--upwards`	Durchsucht Ordner aufwärts nach der 'project.godot' Datei.
`--main-pack <file>`	Pfad zu einer Paketdatei (.pck) zum laden.
`--render-thread <mode>`	Render Thread Modus ('unsafe', 'safe', 'separate'). Siehe Thread Model für weitere Informationen.
`--remote-fs <address>`	Remote Dateisystem (`<Host/IP>[:<Port>]` Addresse).
`--audio-driver <driver>`	Audio-Treiber. Nutze `--help` für eine Liste der verfügbaren Treiber.
`--video-driver <driver>`	Video-Treiber. Nutze `--help` für eine Liste der verfügbaren Treiber.

Anzeige Eigenschaften

Befehl	Beschreibung
`-f`, `--fullscreen`	Vollbildmodus anfordern.
`-m`, `--maximized`	Maximiertes Fenster anfordern.
`-w`, `--windowed`	Fenstermodus anfordern.
`-t`, `--always-on-top`	Ein immer-im-Vordergrund Fenster anfordern.
`--resolution <W>x<H>`	Die Fenster Auflösung abrufen.
`--position <X>,<Y>`	Die Fenster-Position abfragen.
`--low-dpi`	Niedrigen DPI-Modus erzwingen (nur auf MacOS und Windows).
`--no-window`	Deaktiviert die Erstellung von Fenstern. Nützlich zusammen mit `--script`.

Debug Eigenschaften

Bemerkung

Debug-Optionen sind nur im Editor und in Debug-Exportvorlagen verfügbar (sie erfordern debug oder release_debug Build-Ziele, siehe :ref:"doc_introduction_to_the_buildsystem_target" für weitere Details).

Befehl	Beschreibung
`-d`, `--debug`	Debug (localer stdout Debugger).
`-b`, `--breakpoints`	Breakpoint Liste als Quelle::Zeile Komma getrennte Paare, ohne Leerzeichen (nutzte stattdessen %%20).
`--profiling`	Schaltet Profiling in Skript-Debugger ein.
`--remote-debug <address>`	Remote Debug (`<Host/IP>:<Port>` Addresse).
`--debug-collisions`	Zeigt Kollisionsformen während eine Szene läuft.
`--debug-navigation`	Zeigt bei Ausführung der Szene Navigationspolygone an.
`--frame-delay <ms>`	Simuliert eine hohe CPU Auslastung (verzögert jedes Bild um <ms> Millisekunden).
`--time-scale <scale>`	Zeitskala erzwingen (höhere Werte sind schneller, 1,0 ist normale Geschwindigkeit).
`--disable-render-loop`	Deaktiviert die Renderschleife, damit wird nur noch gerendert, wenn es explizit aus dem Skript aufgerufen wird.
`--disable-crash-handler`	Deaktiviert den Crash-Handler, falls vom Plattformcode unterstützt.
`--fixed-fps <fps>`	Erzwingt eine feste Anzahl von Bildern pro Sekunde. Diese Einstellung deaktiviert die Echtzeitsynchronisation.
`--print-fps`	Gibt die FPS (Bilder pro Sekunde) an stdout.

Eigenständige Werkzeuge

Befehl	Beschreibung
`-s <script>`, `--script <script>`	Ein Skript ausführen.
`--check-only`	Nur auf Fehler prüfen und beenden (benutzten mit `--script`).
`--export <target>`	Exportiert das Projekt mit dem angegebenen Exportziel. Exportieren Sie nur das Hauptpaket, wenn der Pfad mit .pck oder .zip endet ( tools muss aktiviert sein).
`--export-debug <target>`	Wie `--export`, aber Debug-Vorlage wird verwendet (tools muss aktiviert sein).
`--doctool <path>`	Speichert den Engine-API-Verweis auf den angegebenen <Pfad> im XML-Format und führen ihn zusammen, wenn vorhandene Dateien gefunden werden (tools muss aktiviert sein).
`--no-docbase`	Verbiete das Ablegen von Basistypen (verwendet mit `--doctool`, tools muss aktiviert sein).
`--build-solutions`	Erstellt die Skriptlösungen (z.B. für C# -Projekte, tools muss aktiviert sein).
`--gdnative-generate-json-api`	Generiert einen JSON-Speicherauszug der Godot-API für GDNative-Bindungen (tools muss aktiviert sein).
`--test <test>`	Führt einen Komponententest durch. Verwenden Sie zuerst `--help`, um die Liste der Tests anzuzeigen. (tools muss aktiviert sein).
`--export-pack <preset> <path>`	Wie `--export`, aber Debug-Vorlage wird verwendet (tools muss aktiviert sein).

Pfad¶

Es wird empfohlen das Godot Programm in die PATH Umgebungsvariable aufzunehmen, so daß es von überall einfach durch Eingabe von godot``erreicht werden kann. Hierfür muss bei Linux die Datei in ``/usr/local/bin stehen und der Name der Datei sollte ``godot``sein.

Projektpfad setzen¶

Abhängig davon wo sich das Godot Programm befindet und welches das aktuelle Arbeitsverzeichnis ist, sollte man den Pfad zum Projekt setzen, damit die folgenden Befehle korrekt funktionieren.

Hierzu kann der Pfad in der project.godot Datei des Projekts entweder wie folgt als erstes Argument eingetragen werden:

godot path_to_your_project/project.godot [other] [commands] [and] [args]

Oder durch Nutzen des --path-Arguments:

godot --path path_to_your_project [other] [commands] [and] [args]

Zum Beispiel, der vollständige Befehl zum exportieren Ihres Spiels (wie unten beschrieben) sieht in etwa so aus:

godot --path path_to_your_project --export my_export_preset_name game.exe

Projekt erzeugen¶

Ein neues Projekt kann auch über die Kommandozeile erzeugt werden indem in der Shell (Eingabeaufforderung) zum gewünschten Verzeichnis gewechselt und eine Datei project.godot erzeugt wird.

mkdir newgame
cd newgame
touch project.godot

Das Projekt kann nun mit Godot geöffnet werden.

Editor starten¶

Den Editor startet man durch ausführen von Godot mit dem -e Flag. Dies muss aus dem Projekt-Verzeichnis oder einem Unterverzeichnis geschehen, ansonsten wird der Befehl ignoriert und der Projekt Manager erscheint.

godot -e

Eine Szene wurde erzeugt und gespeichert, sie kann später editiert werden mit dem gleichen Code und der Szene als Argument.

godot -e scene.tscn

Szene löschen¶

Godot schont Ihr Filesystem und wird keine extra Metadata Dateien erzeugen. Nutzen Sie rm um eine Szenendatei zu löschen. Stellen Sie sicher, dass nichts auf diese Szene verweist, ansonsten wird beim Öffnen ein Fehler angezeigt.

rm scene.tscn

Spiel starten¶

Um das Spiel zu starten einfach Godot ausführen innerhalb des Projekt Verzeichnisses oder Unterverzeichnisses.

godot

Wenn eine spezielle Szene getestet werden muss, füge diese Szene in der Eingabeaufforderung ein.

godot scene.tscn

Debugging¶

Auf der Kommandozeile Fehler erkennen ist schwierig, da diese nur so vorbeirauschen. Hierfür gibt es einen Kommandozeilen-Debugger indem -d angefügt wird. Dies funktioniert sowohl mit Spielen als auch einfachen Szenen.

godot -d

godot -d scene.tscn

Exportieren¶

Das Exportieren des Projekts über die Befehlszeile wird ebenfalls unterstützt. Dies ist besonders nützlich für kontinuierliche Integrations-Setups. Die kopflose Version von Godot (Server-Build, kein Video) ist dafür ideal.

godot --export "Linux/X11" /var/builds/project
godot --export Android /var/builds/project.apk

Der Name der Voreinstellung muss mit dem Namen einer Exportvoreinstellung übereinstimmen, die in der Datei export_presets.cfg des Projekts definiert ist. Wenn der Voreinstellungsname Leerzeichen oder Sonderzeichen enthält (z. B. "Windows Desktop"), muss er mit Anführungszeichen umgeben werden.

Um eine Debug-Version des Spiels zu exportieren, verwenden Sie den Schalter --export-debug anstelle von --export. Ihre Parameter und Verwendung sind gleich.

Um nur eine PCK-Datei zu exportieren, verwenden Sie die Option --export-pack gefolgt vom voreingestellten Namen und Ausgabepfad mit der Dateierweiterung anstelle von --export. Die Ausgabepfaderweiterung bestimmt das Format des Pakets, entweder PCK oder ZIP.

Warnung

Wenn ein relativer Pfad als Pfad für --export, --export-debug oder --export-pack angegeben wird, ist der Pfad relativ zu dem Verzeichnis, das die Datei project.godot enthält, nicht relativ zum aktuellen Arbeitsverzeichnis.

Ein Skript ausführen¶

Es ist möglich, ein einfaches .gd -Skript über die Befehlszeile auszuführen. Diese Funktion ist besonders nützlich in großen Projekten, z.B. für die Stapelkonvertierung von Assets oder den benutzerdefinierten Import/Export.

Das Skript muss von SceneTree oder MainLoop erben.

Hier ein kleines ``sayhello.gd` Beispiel wie es funktioniert:

#!/usr/bin/env -S godot -s
extends SceneTree

func _init():
    print("Hello!")
    quit()

Und so wird es ausgeführt:

# Prints "Hello!" to standard output.
godot -s sayhello.gd

Falls im Pfad kein project.godot existiert wird der aktuelle Pfad als aktuelles Arbeitsverzeichnis angenommen (es sei denn, --path ist angegeben).

Die erste Zeile von sayhello.gd oben wird allgemein als shebang bezeichnet. Wenn sich die Godot-Binärdatei in Ihrem PATH als godot befindet, können Sie das Skript in modernen Linux-Distributionen sowie unter MacOS wie folgt ausführen:

# Mark script as executable.
chmod +x sayhello.gd
# Prints "Hello!" to standard output.
./sayhello.gd

Wenn das oben Genannte unter Ihrer aktuellen Linux oder MacOS Version nicht funktioniert, können Sie den "Shebang" immer wie folgt direkt von Godot ausführen lassen:

#!/usr/bin/godot -s