Tutoriel de ligne de commande¶

Certains développeurs aiment beaucoup utiliser la ligne de commande. Godot est conçu pour leur être agréable, alors voici les étapes pour travailler entièrement à partir de la ligne de commande. Étant donné que le moteur ne nécessite que peu ou pas de bibliothèques externes, les temps d’initialisation sont assez rapides, ce qui le rend adapté à cette méthode de travail.

Référence de ligne de commande¶

Options générales

Commande	Description
`-h`, `--help`, `/?`	Affiche la liste des options de ligne de commande.
`--version`	Afficher la chaîne de caractère de version.
`-v`, `--verbose`	Utilise le mode verbeux pour la sortie standard (stdout).
`--quiet`	Mode silencieux qui désactive les messages en console. Les erreurs sont tout de même affichées.

Options d'exécution

Commande	Description
`-e`, `--editor`	Démarre l'éditeur au lieu de lancer la scène (tools doit être activé).
`-p`, `--project-manager`	Démarre le gestionnaire de projets, même si un projet est détecté automatiquement (tools doit être activé).
`-q`, `--quit`	Quitter après la première itération.
`-l <locale>`, `--language <locale>`	Utiliser un paramètre régional spécifique (<locale> étant un code de deux lettres). Se référer à Versions de langues pour plus d'informations.
`--path <répertoire>`	Chemin vers un projet (<répertoire> doit contenir un fichier 'project.godot').
`-u`, `--upwards`	Analyser les dossiers vers le haut pour trouver le fichier 'project.godot'.
`--main-pack <file>`	Chemin vers le fichier pack (.pck) à charger.
`--render-thread <mode>`	Mode de rendu de thread ('unsafe', 'safe', 'separate'). Se référer à Thread Model pour plus d'informations.
`--remote-fs <address>`	Système de fichiers distant (Adresse `<hôte/IP>[:<port>]`).
`--audio-driver <driver>`	Pilotes audio. Utilisez d'abord la commande `--help` pour afficher la liste des pilotes disponibles.
`--video-driver <driver>`	Pilote vidéo. Utilisez d'abord la commande `--help` pour afficher la liste des pilotes disponibles.

Options d'affichage

Commande	Description
`-f`, `--fullscreen`	Demander le mode plein écran.
`-m`, `--maximized`	Demander une fenêtre maximisée.
`-w`, `--windowed`	Demander le mode fenêtré.
`-t`, `--always-on-top`	Demander une fenêtre toujours au premier plan.
`--resolution <W>x<H>`	Demander la résolution de la fenêtre.
`--position <X>,<Y>`	Demander la position de la fenêtre.
`--low-dpi`	Force le mode low-DPI (faible-ppp). Disponible uniquement sur macOS et Windows.
`--no-window`	Désactive la création de fenêtre (seulement sur Windows). À utiliser conjointement avec `--script`.

Options de débogage

Note

Les options de débogage ne sont disponibles que dans l'éditeur et les modèles d'exportation de débogage (elles nécessitent des cibles de compilation debug ou release_debug, voir Cible pour plus de détails).

Commande	Description
`-d`, `--debug`	Débogage (débogueur stdout local).
`-b`, `--breakpoints`	Liste de points d'arrêt comme paires source::ligne séparées par des virgules, sans espace (utiliser %%20 à la place).
`--profiling`	Activer le profilage dans le débogueur de script.
`--remote-debug <address>`	Débogage à distance (adresse `<host/IP>:<port>`).
`--debug-collisions`	Afficher les formes de collision lors de l'exécution de la scène.
`--debug-navigation`	Afficher les polygones de navigation lors de l'exécution de la scène.
`--frame-delay <ms>`	Simuler une charge CPU élevée (retarder chaque trame de <ms> millisecondes).
`--time-scale <scale>`	Forcer l'échelle de temps (plus rapide avec des valeurs plus élevées, 1.0 pour une vitesse normale).
`--disable-render-loop`	Désactive la boucle de rendu pour que le rendu ne se produise que lorsqu'il est appelé explicitement depuis le script.
`--disable-crash-handler`	Désactiver le gestionnaire de crash lorsqu'il est pris en charge par le code de la plate-forme.
`--fixed-fps <fps>`	Force un nombre fixe d'images par seconde. Ce paramètre désactive la synchronisation temps-réel.
`--print-fps`	Affiche les images par second à la sortie standard stdout.

Outils autonomes

Commande	Description
`-s <script>`, `--script <script>`	Exécutez un script.
`--check-only`	Analyser uniquement les erreurs et quitter (utiliser avec `--script`).
`--export <target>`	Exporter le projet en utilisant la cible d'exportation donnée. Exporter seulement le paquet principal si le chemin se termine par.pck ou.zip (tools doivent être activés).
`--export-debug <target>`	Comme `--export`, mais utilise le modèle de débogage (tools doivent être activés).
`--doctool <path>`	Écrire la référence de l'API du moteur vers le chemin <path> au format XML, fusionnant les fichiers s'ils existent (tools doivent être activés).
`--no-docbase`	Ne pas écrire les références des types de base (utilisé avec `--doctool`, tools doivent être activés).
`--build-solutions`	Construire les solutions de script (par exemple pour les projets C#, tools doivent être activés).
`--gdnative-generate-json-api`	Génération d'un dump JSON de l'API Godot pour les bindings GDNative (tools doivent être activés).
`--test <test>`	Effectuez un test unitaire. Utilisez d'abord `--help` pour afficher la liste des tests. (tools doivent être activés).
`--export-pack <preset> <path>`	Comme `--export`, mais n'exporter que le pack de jeu pour le préréglage donné. L'extension <path> détermine s'il sera au format PCK ou ZIP. (tools doit être activée).

Chemin¶

Il est recommandé que votre binaire Godot soit dans votre variable d'environnement PATH, de sorte qu'il puisse être exécuté facilement à partir de n'importe quel endroit en tapant godot. Vous pouvez le faire sous Linux en plaçant le binaire Godot dans /usr/local/bin et en vous assurant qu'il s'appelle godot.

Définir le chemin du projet¶

Selon l'endroit où se trouve votre binaire Godot et votre répertoire de travail actuel, vous devrez peut-être définir le chemin d'accès à votre projet pour que les commandes suivantes fonctionnent correctement.

Cela peut être fait en donnant le chemin du fichier project.godot de votre projet en tant que premier argument, comme ceci :

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

ou en utilisant l'argument --path :

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

Par exemple, la commande complète pour exporter votre jeu (comme expliqué ci-dessous) pourrait ressembler à ceci :

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

Créer un projet¶

La création d'un projet à partir de la ligne de commande peut se faire en naviguant dans le shell jusqu'à l'endroit désiré et en créant un fichier project.godot.

mkdir newgame
cd newgame
touch project.godot

Le projet peut maintenant être ouvert avec Godot.

Exécution de l'éditeur¶

L'exécution de l'éditeur se fait en exécutant Godot avec le paramètre -e. Cela doit être fait depuis le répertoire du projet ou un sous-répertoire, sinon la commande est ignorée et le gestionnaire de projet apparaît.

godot -e

Si une scène a été créée et enregistrée, elle peut être modifiée ultérieurement en exécutant le même code avec la dite scène en argument.

godot -e scene.tscn

Effacer une scène¶

Godot respecte votre système de fichiers et ne créera pas de fichiers de métadonnées supplémentaires. Utilisez rm pour effacer un fichier de scène. Assurez-vous que rien ne fait référence à cette scène, sinon cela provoquera une erreur à l’ouverture.

rm scene.tscn

Éxécuter le jeu¶

Pour lancer le jeu, il suffit d'exécuter Godot dans le répertoire ou sous-répertoire du projet.

godot

Lorsqu'une scène spécifique doit être testée, passez cette scène à la ligne de commande.

godot scene.tscn

Débogage¶

Intercepter les erreurs dans la ligne de commande peut être une tâche difficile car elles ne font que défiler. Pour cela, un débogueur de ligne de commande est fourni en ajoutant -d. Cela fonctionne à la fois pour exécuter le jeu ou une simple scène.

godot -d

godot -d scene.tscn

Exportation¶

L'exportation du projet à partir de la ligne de commande est également prise en charge. Ceci est particulièrement utile pour les configurations d'intégration continue. La version headless, littéralement « sans tête », de Godot (version serveur, sans affichage vidéo) est idéale pour cela.

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

Le nom du préréglage doit correspondre au nom d'un préréglage d'exportation défini dans le fichier export_presets.cfg du projet. Si le nom du préréglage contient des espaces ou des caractères spéciaux (tels que "Windows Desktop"), il doit être entouré de guillemets.

Pour exporter une version de débogage du jeu, utilisez le commutateur --export-debug au lieu de --export. Leurs paramètres et leur utilisation sont les mêmes.

Pour exporter uniquement un fichier PCK, utilisez l'option --export-pack suivie du nom du préréglage et du chemin de sortie, avec l'extension du fichier, au lieu de --export. L'extension du chemin de sortie détermine le format du paquet, soit PCK soit ZIP.

Avertissement

Lorsque vous spécifiez un chemin relatif comme chemin pour --export, --export-debug ou --export-pack, le chemin sera relatif au répertoire contenant le fichier project.godot, non relatif au répertoire de travail actuel.

Exécuter un script¶

Il est possible d'exécuter un simple script .gd en ligne de commande. Cette fonctionnalité est particulièrement utile dans les grands projets, par exemple pour la conversion de ressources(asset), ou l’import/export personnalisé.

Le script doit hériter de SceneTree ou MainLoop.

Voici un exemple simple de fonctionnement de sayhello.gd :

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

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

Et comment l'exécuter :

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

Si aucun fichier project.godot n'existe au chemin, le chemin courant est supposé être le répertoire de travail courant (sauf si --path est spécifié).

La première ligne de sayhello.gd ci-dessus est communément appelée shebang. Si le binaire Godot se trouve dans votre PATH en tant que godot, il vous permet d'exécuter le script comme suit dans les distributions Linux modernes, ainsi que dans macOS :

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

Si ce qui précède ne fonctionne pas dans votre version actuelle de Linux ou de macOS, vous pouvez toujours faire en sorte que le shebang exécute Godot directement à partir de l'endroit où il se trouve comme suit :

#!/usr/bin/godot -s