Up to date

This page is up to date for Godot 4.2. If you still find outdated information, please open an issue.

Kommandozeilen-Tutorial

Einige Entwickler verwenden gerne und ausgiebig die Befehlszeile. Godot ist so konzipiert, dass es mit ihnen kompatibel ist. Hier sind die Schritte, um vollständig über die Befehlszeile zu arbeiten. Da die Engine fast keine externen Bibliotheken benötigt, sind die Initialisierungszeiten recht kurz, was sie für diesen Workflow geeignet macht.

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 Kommandozeile entsprechend ändern.

Kommandozeilen-Referenz

Legende

  • Release Verfügbar in Editor-Builds, Debug-Exportvorlagen und Release-Exportvorlagen.

  • Debuggen Nur in Editor-Builds und Debug-Exportvorlagen verfügbar.

  • Editor Nur in Editor-Builds verfügbar.

Beachten Sie, dass unbekannte Kommandozeilenargumente keinerlei Auswirkungen haben. Die Engine wird Sie nicht warnen, wenn Sie ein Kommandozeilenargument verwenden, das für einen bestimmten Build-Typ nicht existiert.

Allgemeine Optionen

Befehl

Beschreibung

-h, --help

Release Zeigt die Liste der Kommandozeilenoptionen an.

--version

Release Zeigt den Versions-String an.

-v, --verbose

Release Ausführlichen stdout-Modus verwenden.

-q, --quiet

Release Stummer Modus, unterdrückt stdout-Meldungen. Fehler werden weiterhin angezeigt.

Ausführen-Optionen

Befehl

Beschreibung

--, ++

Release Trennzeichen für vom Benutzer bereitgestellte Argumente. Die folgenden Argumente werden nicht von der Engine verwendet, können aber von OS.get_cmdline_user_args() gelesen werden.

-e, --editor

Editor Editor starten, anstatt die Szene ablaufen zu lassen.

-p, --project-manager

Editor Projektmanager starten, auch wenn ein Projekt automatisch erkannt wird.

--debug-server <uri>

Editor Debug-Server des Editors starten (<protocol>://<host/IP>[:<port>], z.B. tcp://127.0.0.1:6007)

--quit

Release Nach der ersten Iteration beenden.

--quit-after

Release Beenden nach der angegebenen Anzahl von Iterationen. Zum Deaktivieren auf 0 setzen.

-l, --language <locale>

Release Ein bestimmtes Gebietsschema verwenden. <locale> folgt dem Format language_Script_COUNTRY_VARIANT, wobei language ein 2- oder 3-stelliger Sprachcode in Kleinbuchstaben und der Rest optional ist. Siehe Gebietsschema-Codes für weitere Details.

--path <Verzeichnis>

Release Pfad zu einem Projekt (<Verzeichnis> muss eine 'project.godot'-Datei enthalten).

-u, --upwards

Release Ordner aufwärts nach der Datei "project.godot" durchsuchen.

--main-pack <file>

Release Pfad zu einer zu ladenden Pack-Datei (.pck).

--render-thread <mode>

Release Render-Thread-Modus ('unsafe', 'safe', 'separate'). Siehe Thread-Modell für weitere Details.

--remote-fs <address>

Release Remote-Dateisystem (<host/IP>[:<port>]-Adresse).

--remote-fs-password <password>

Release Passwort für Remote-Dateisystem.

--audio-driver <driver>

Release Audiotreiber. Verwenden Sie zuerst --help, um die Liste der verfügbaren Treiber anzuzeigen.

--display-driver <driver>

Release Display-Treiber (und Rendering-Treiber). Verwenden Sie zuerst --help, um die Liste der verfügbaren Treiber anzuzeigen.

--rendering-method <renderer>

Release Renderer-Name. Erfordert Treiberunterstützung.

--rendering-driver <driver>

Release Rendering-Treiber (abhängig vom Display-Treiber). Verwenden Sie zuerst --help, um die Liste der verfügbaren Treiber anzuzeigen.

--gpu-index <device_index>

Release Eine bestimmte GPU verwenden (mit --verbose ausführen, um eine Liste der verfügbaren Geräte zu erhalten).

--text-driver <driver>

Release Texttreiber (Schriftarten, BiDi, Shaping).

--tablet-driver <driver>

Release Stifttablett-Eingabetreiber.

--headless

Release Aktivieren Sie den Headless-Modus (--display-driver headless --audio-driver Dummy). Nützlich für Server und mit --script.

--write-movie <file>

Release Führt die Engine so aus, dass ein Film geschrieben wird (normalerweise mit .avi oder .png-Erweiterung). --fixed-fps wird erzwungen, falls aktiviert, kann aber verwendet werden, um die FPS des Films zu ändern. --disable-vsync kann das Schreiben von Filmen beschleunigen, macht aber die Interaktion schwieriger. --quit-after kann verwendet werden, um die Anzahl der zu schreibenden Bilder festzulegen.

Anzeige-Optionen

Befehl

Beschreibung

-f, --fullscreen

Release Vollbildmodus anfordern.

-m, --maximized

Release Maximiertes Fenster anfordern.

-w, --windowed

Release Fenstermodus anfordern.

-t, --always-on-top

Release Fenster anfordern, das immer im Vordergrund ist.

--resolution <W>x<H>

Release Fenster-Auflösung anfordern.

--position <X>,<Y>

Release Fenster-Position anfordern.

--screen <N>

Release Fenster-Bildschirm anfordern.

--single-window

Release Einzelnes Fenster verwenden (keine separaten Unterfenster).

--xr-mode <mode>

Release XR-Modus auswählen ("Standard", "Aus", "Ein").

Debug-Optionen

Befehl

Beschreibung

-d, --debug

Release Debug (lokaler stdout-Debugger).

-b, --breakpoints

Release Haltepunktliste als source::line Komma-getrennte Paare, keine Leerzeichen (stattdessen %20 verwenden).

--profiling

Release Profiling im Skript-Debugger einschalten.

--gpu-profile

Release GPU-Profil der Aufgaben anzeigen, die während des Frame-Renderings die meiste Zeit in Anspruch genommen haben.

--gpu-validation

Release Grafik-API Validation Layers zur Fehlersuche aktivieren.

--gpu-abort

Debuggen Abbruch bei GPU-Fehlern (in der Regel Validation Layer-Fehler), kann helfen, das Problem zu erkennen, wenn Ihr System einfriert.

--remote-debug <uri>

Release Remote-Debug (<protocol>://<host/IP>[:<port>], z.B. tcp://127.0.0.1:6007).

--single-threaded-scene

Release Szenenbaum läuft im Single-Thread-Modus. Sub-Thread-Gruppen sind deaktiviert und laufen auf dem Haupt-Thread.

--debug-collisions

Debuggen Kollisions-Shapes beim Ausführen der Szene anzeigen.

--debug-paths

Debuggen Pfadlinien beim Ausführen der Szene anzeigen.

--debug-navigation

Debuggen Navigationspolygone beim Ausführen der Szene anzeigen.

--debug-avoidance

Debuggen Debug-Visualisierungen zur Navigationsvermeidung anzeigen, wenn die Szene ausgeführt wird.

--debug-stringnames

Debuggen Alle StringName-Zuweisungen auf stdout ausgeben, wenn die Engine beendet wird.

--frame-delay <ms>

Release Hohe CPU-Last simulieren (verzögert jedes Bild um <ms> Millisekunden).

--time-scale <scale>

Release Zeitskala erzwingen (höhere Werte sind schneller - 1,0 ist normale Geschwindigkeit).

--disable-vsync

Release Deaktivierung der vertikalen Synchronisation erzwingen, auch wenn sie in den Projekteinstellungen aktiviert ist. Die V-Sync-Erzwingung auf Treiberebene wird nicht außer Kraft gesetzt.

--disable-render-loop

Release Rendering-Schleife deaktivieren, so dass das Rendering nur erfolgt, wenn es explizit vom Skript aufgerufen wird.

--disable-crash-handler

Release Crash-Handler deaktivieren, wenn vom Plattformcode unterstützt.

--fixed-fps <fps>

Release Feste Anzahl von Bildern pro Sekunde erzwingen. Mit dieser Einstellung wird die Echtzeitsynchronisation deaktiviert.

--delta-smoothing <enable>

Release Delta-Glättung aktivieren oder deaktivieren ('enable', 'disable').

--print-fps

Release Frames pro Sekunde auf stdout ausgeben.

Eigenständige Tools

Befehl

Beschreibung

-s, --script <script>

Release Skript ausführen.

--check-only

Release Nur auf Fehler prüfen und beenden (mit --script verwenden).

--export-release <preset> <path>

Editor Projekt mit der angegebenen Vorgabe und der passenden Release-Vorlage exportieren. Der Name der Vorgabe sollte mit einem in export_presets.cfg definierten Namen übereinstimmen. <Pfad> sollte absolut oder relativ zum Projektverzeichnis sein und den Dateinamen für das Binary enthalten (z.B. 'builds/game.exe'). Das Zielverzeichnis sollte existieren.

--export-debug <preset> <path>

Editor Wie --export-release, aber mit Debug-Vorlage.

--export-pack <preset> <path>

Editor Wie --export-release, aber exportiert nur das Spielpaket für die angegebene Voreinstellung. Die <Pfad>-Erweiterung bestimmt, ob es im PCK- oder ZIP-Format sein wird.

--convert-3to4 [<max_file_kb>] [<max_line_size>]

Editor Projekt von Godot 3.x nach Godot 4.x konvertieren.

--validate-conversion-3to4 [<max_file_kb>] [<max_line_size>]

Editor Zeigt an, welche Elemente bei der Konvertierung eines Projekts von Godot 3.x nach Godot 4.x umbenannt werden.

--doctool [<path>]

Editor Engine-API-Referenz auf den angegebenen <Pfad> im XML-Format ausgeben, Mergen, wenn vorhandene Dateien gefunden werden.

--no-docbase

Editor Dumping der Basistypen verbieten (verwendet mit --doctool).

--gdscript-docs <path>

Editor API-Referenz aus der Inline-Dokumentation in den GDScript-Dateien in <Pfad> generieren (verwendet mit --doctool), anstatt die Engine-API zu dumpen.

--build-solutions

Editor Bauen der Skripting-Solutions (z.B. für C# Projekte). Impliziert --editor und erfordert ein gültiges Projekt zum Bearbeiten.

--dump-gdextension-interface

Editor GDExtension-Header-Datei 'gdnative_interface.h' im aktuellen Ordner generieren. Diese Datei ist die Basisdatei, die zur Implementierung einer GDExtension benötigt wird.

--dump-extension-api

Editor JSON-Dump der Godot-API für GDExtension-Bindungen mit dem Namen 'extension_api.json' im aktuellen Ordner generieren.

--validate-extension-api <path>

Editor Erweiterungs-API-Datei validieren, die (mit der obigen Option) aus einer früheren Version der Engine kopiert wurde, um die API-Kompatibilität sicherzustellen. Wenn Inkompatibilitäten oder Fehler entdeckt werden, ist der Rückgabewert ungleich Null.

--benchmark

Editor Benchmarking der Laufzeit und Ausgabe auf der Konsole.

--benchmark-file <path>

Editor Benchmarking der Laufzeit und Speichern in einer angegebenen Datei im JSON-Format. Der Pfad sollte absolut sein.

Pfad

Es wird empfohlen, die Godot-Editor-Binärdatei in der PATH-Umgebungsvariablen zu platzieren, so dass sie leicht von jedem Ort aus durch Eingabe von godot ausgeführt werden kann. Unter Linux können Sie dies tun, indem Sie die Godot-Binärdatei in /usr/local/bin ablegen und sicherstellen, dass sie godot heißt (Groß- und Kleinschreibung beachten).

Um dies unter Windows oder macOS einfach zu erreichen, können Sie Godot mit Scoop (unter Windows) oder Homebrew (unter macOS) installieren. Dadurch wird die installierte Kopie von Godot automatisch im PATH verfügbar gemacht:

# Standard editor:
scoop install godot

# Editor with C# support (will be available as `godot-mono` in `PATH`):
scoop install godot-mono

Projektpfad setzen

Je nachdem, wo sich Ihre Godot-Binärdatei befindet und welches Ihr aktuelles Arbeitsverzeichnis ist, müssen Sie möglicherweise den Pfad zu Ihrem Projekt festlegen, damit einer der folgenden Befehle korrekt funktioniert.

When running the editor, this can be done by giving the path to the project.godot file of your project as either the first argument, like this:

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

For all commands, this can be done by using the --path argument:

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 --headless --path path_to_your_project --export-release my_export_preset_name game.exe

When starting from a subdirectory of your project, use the --upwards argument for Godot to automatically find the project.godot file by recursively searching the parent directories.

For example, running a scene (as explained below) nested in a subdirectory might look like this when your working directory is in the same path:

godot --upwards nested_scene.tscn

Projekt erzeugen

Ein Projekt kann von der Kommandozeile aus erstellt werden, indem man in der Shell zum gewünschten Ort navigiert und eine project.godot-Datei erstellt.

mkdir newgame
cd newgame
touch project.godot

Das Projekt kann nun mit Godot geöffnet werden.

Editor starten

Running the editor is done by executing Godot with the -e flag. This must be done from within the project directory or by setting the project path as explained above, otherwise the command is ignored and the Project Manager appears.

godot -e

When passing in the full path to the project.godot file, the -e flag may be omitted.

Wenn eine Szene erstellt und gespeichert wurde, kann sie später bearbeitet werden, indem derselbe Code mit dieser Szene als Argument ausgeführt wird.

godot -e scene.tscn

Szene löschen

Godot ist mit wird Ihrem Dateisystem zuliebe keine zusätzlichen Metadaten-Dateien erstellen. Verwenden Sie rm, um eine Szenendatei zu löschen. Stellen Sie sicher, dass nichts auf diese Szene verweist. Andernfalls wird beim Öffnen des Projekts ein Fehler ausgelöst.

rm scene.tscn

Spiel starten

To run the game, execute Godot within the project directory or with the project path as explained above.

godot

Note that passing in the project.godot file will always run the editor instead of running the game.

Wenn eine spezielle Szene getestet werden soll, fügen Sie diese Szene in die Eingabeaufforderung ein.

godot scene.tscn

Debugging

Das Auffinden von Fehlern in der Kommandozeile kann eine schwierige Aufgabe sein, da sie schnell durchlaufen. Zu diesem Zweck wird ein Kommandozeilen-Debugger durch Hinzufügen von -d bereitgestellt. Er funktioniert entweder für das Spiel oder eine einzelne Szene.

godot -d
godot -d scene.tscn

Exportieren

Das Exportieren des Projekts von der Kommandozeile aus wird ebenfalls unterstützt. Dies ist besonders nützlich für die Continuous Integration.

Bemerkung

Die Verwendung des Kommandozeilenarguments --headless ist erforderlich auf Plattformen, die keinen GPU-Zugriff haben (z.B. Continuous Integration). Auf Plattformen mit GPU-Zugriff verhindert --headless, dass ein Fenster erscheint, während das Projekt exportiert wird.

# `godot` must be a Godot editor binary, not an export template.
# Also, export templates must be installed for the editor
# (or a valid custom export template must be defined in the export preset).
godot --headless --export-release "Linux/X11" /var/builds/project
godot --headless --export-release Android /var/builds/project.apk

Der Name der Vorgabe muss mit dem Namen einer Exportvorgabe übereinstimmen, die in der Datei export_presets.cfg des Projekts definiert ist. Wenn der Vorgabenname 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-release. Die Parameter und die Verwendung sind die gleichen.

Um nur eine PCK-Datei zu exportieren, verwenden Sie die Option --export-pack, gefolgt von dem Vorgabenamen und dem Ausgabepfad, mit der Dateierweiterung, anstelle von --export-release oder --export-debug. Die Erweiterung des Ausgabepfades bestimmt das Format des Pakets, entweder PCK oder ZIP.

Warnung

Wenn ein relativer Pfad als Pfad für --export-release, --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 .gd-Skript über die Befehlszeile auszuführen. Diese Funktion ist besonders bei großen Projekten nützlich, z.B. für die Batch-Konvertierung von Assets oder den benutzerdefinierten Import/Export.

Das Skript muss von SceneTree oder MainLoop erben.

Hier ist ein Beispiel sayhello.gd, das zeigt, 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

Wenn kein project.godot im Pfad existiert, wird der aktuelle Pfad als das aktuelle 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