Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Creare applicazioni

Godot dispone di un ampio sistema di UI integrato, e la sua piccola dimensione di distribuzione può renderlo un'alternativa adatta a framework come Electron o Qt.

Questa pagina fornisce linee guida per la creazione di applicazioni non di gioco con Godot, nonché istruzioni su come effettuare attività comuni per migliorare l'integrazione con il desktop.

Nota

Godot è prima di tutto un motore di gioco. Ciò significa che la creazione di applicazioni con Godot è una conseguenza delle sue funzionalità, e non il suo obiettivo principale di sviluppo.

Vedi anche

Controlla Material Maker e Pixelorama per esempi di applicazioni open source fatte con Godot.

Effettuare attività comuni

Generare più di una finestra

Questo è supportato solo su Windows, macOS, Linux (solo X11/XWayland, non in modalità nativa di Wayland).

È possibile creare finestre aggiuntive attraverso il nodo Window. È possibile spostare, ridimensionare, ridurre a icona e chiudere le finestre indipendentemente dalla finestra principale dell'applicazione.

Tuttavia, se si chiude la finestra principale, si chiuderanno anche tutte le altre finestre, poiché la chiusura della finestra principale termina il processo. Ciò si può evitare riducendo a icona la finestra principale, impostando la sua proprietà unfocusable su true (per nasconderla dalla barra delle applicazioni e dal selettore di attività), e poi creando nodi Window aggiuntivi subito all'avvio. Si consiglia di fornire un metodo alternativo per uscire dall'applicazione in questo caso, come ad esempio un'icona nella barra delle applicazioni.

Limitare le dimensioni della finestra

La maggior parte delle applicazioni è in grado di renderizzare correttamente solo a partire da determinate dimensioni minime per la finestra. Per casi d'uso più specifici, potrebbe essere opportuno imporre dimensioni massime.

È possibile imporre limiti di dimensione tramite le proprietà min_size e max_size su un nodo Window. Ricordarsi di moltiplicare questi limiti di dimensione in base al fattore di scala dell'applicazione (consultare Adattare a schermi hiDPI per i dettagli).

Suggerimento

Come promemoria, è possibile recuperare il nodo radice Window per impostarne le proprietà tramite get_window() su qualsiasi nodo.

Utilizzare le finestre di dialogo native dei file

Questo è supportato solo su Windows, macOS, Linux e Android.

Come predefinito, Godot utilizza la propria implementazione di FileDialog per le finestre di dialogo dei file. Tuttavia, è possibile utilizzare le finestre di dialogo native del sistema operativo. Questa soluzione è generalmente preferita dagli utenti, poiché le finestre di dialogo native si integrano meglio con l'ambiente desktop e offrono un'esperienza più familiare.

È possibile abilitare le finestre di dialogo native per i file abilitando la proprietà use_native_dialog sul nodo FileDialog. Questo si deve fare su ogni nodo FileDialog utilizzato nel progetto, poiché non esiste un'impostazione del progetto per controllare questo comportamento globalmente.

Confronto tra il FileDialog standard (a sinistra) e la finestra di dialogo nativa dei file (a destra) su macOS

Confronto tra il FileDialog standard (a sinistra) e la finestra di dialogo nativa dei file (a destra) su macOS

Nota

Consultare la descrizione della proprietà per i dettagli sul supporto per ogni piattaforma.

Inoltre, su macOS, le finestre di dialogo native dei file non sono supportate quando l'incorporamento del gioco è abilitato nell'editor. Per testare questa funzionalità durante l'esecuzione del progetto, assicurati di disabilitare l'incorporamento del gioco passando alla schermata Gioco, cliccando sull'icona più a destra nella barra in alto e deselezionando Incorpora gioco al prossimo avvio.

Creare un'icona nella barra delle applicazioni

Questo è supportato solo su Windows e macOS.

È possibile creare una o più icone nella barra delle applicazioni (nota anche come area di notifica) usando un nodo StatusIndicator. Oltre a un tooltip, a questo nodo si può assegnare un nodo PopupMenu, in modo che appaia un menu a tendina quando clicca sull'icona.

StatusIndicator ha anche un segnale pressed che viene emesso quando si clicca sull'icona. Usalo per eseguire un'azione senza far apparire un menu a tendina, oppure per effettuare azioni diverse a seconda del pulsante del mouse premuto.

Dopo aver creato un'icona nella barra delle applicazioni, si potrebbe voler implementare anche il comportamento "riduci a icona alla chiusura". Ciò significa che quando l'utente tenta di chiudere l'applicazione premendo il pulsante X del gestore delle finestre, questa sarà ridotta a icona nella barra delle applicazioni. Per fare ciò, allega questo script a una scena Autoload con un StatusIndicator come nodo radice:

extends StatusIndicator

# Disable this behavior when running from the editor with game embedding,
# as it doesn't cooperate well.
var tray_icon_supported = (
        DisplayServer.has_feature(DisplayServer.FEATURE_STATUS_INDICATOR)
        and not Engine.is_embedded_in_editor()
    )


func _ready():
    visible = false

    if tray_icon_supported:
        get_tree().auto_accept_quit = false
        get_window().focus_entered.connect(
                func():
                    # Hide the tray icon when the window gains focus,
                    # which means it was restored from its minimized state.
                    visible = false
            )
        pressed.connect(
                func(_mouse_button, _position):
                    # Restore the application when the tray icon is clicked.
                    get_window().mode = Window.MODE_WINDOWED
            )


func _notification(what):
    if not tray_icon_supported:
        return

    match what:
        NOTIFICATION_WM_CLOSE_REQUEST:
            get_window().mode = Window.MODE_MINIMIZED
            # Show the tray icon.
            visible = true

Consultare Handling quit requests per i dettagli su come sovrascrivere il comportamento quando l'utente tenta di chiudere l'applicazione. È importante gestire questa situazione quando l'utente ha modifiche non salvate per evitare la perdita di dati.

Nota

Quando sono presenti più nodi StatusIndicator, il loro ordine nella barra delle applicazioni è determinato dall'ordine in cui vengono aggiunti all'albero di scene.

Utilizzare il menu globale

Questo è supportato solo su macOS.

Su macOS, le applicazioni possono utilizzare la barra dei menu globale del sistema anziché visualizzare una barra dei menu dentro la finestra dell'applicazione. In Godot, questo è anche detto menu nativo.

Confronto tra MenuBar standard (a sinistra), la MenuBar con popup nativi (al centro) e il menu nativo (a destra) su macOS

Confronto tra MenuBar standard (a sinistra), la MenuBar con popup nativi (al centro) e il menu nativo (a destra) su macOS

Godot supporta la creazione di menu tramite il nodo MenuBar, che visualizza i suoi figli PopupMenu come menu. È possibile abilitare il supporto per i menu globali su un determinato nodo MenuBar abilitando la sua proprietà prefer_global_menu nell'ispettore. Su macOS, questo farà sì che il nodo MenuBar scompaia e non occupi spazio, e i suoi menu saranno visualizzati nella barra dei menu globale del sistema. Se questa proprietà è disabilitata, il nodo MenuBar visualizzerà i suoi menu dentro della finestra dell'applicazione come al solito, ma i popup nativi saranno comunque usati se supportati dal sistema operativo.

Nota

Il menu dell'app (con il nome del progetto in grassetto), così come i menu Window e Help, sono sempre presenti su macOS. Non si dovrebbero aggiungere manualmente al menu globale.

A partire da Godot 4.6, è possibile aggiungere nuove voci a questi menu modificando la proprietà system_menu_id sul nodo PopupMenu. È possibile scegliere tra Application Menu (il primo menu con il nome dell'applicazione in grassetto), Window Menu, Help Menu e Dock (visualizzato facendo clic destro sull'icona nel Dock). Le solite voci già presenti in questi menu verranno mantenute:

Opzioni personalizzate aggiunte al menu Finestra di sistema su macOS

Opzioni personalizzate aggiunte al menu Finestra di sistema su macOS

Un progetto può avere più nodi MenuBar. Se più nodi MenuBar hanno la proprietà Prefer Global Menu abilitata, le opzioni del menu verranno aggiunte all'indice definito dalla proprietà Start Index quando il nodo MenuBar viene aggiunto all'albero di scene. Ciò consente di posizionare menu specifici del contesto alla fine della barra dei menu, in modo che le prime opzioni del menu rimangano al loro posto quando la barra dei menu in più viene aggiunta o rimossa.

Per casi d'uso più avanzati, è possibile usare direttamente il singleton NativeMenu senza ricorrere al nodo MenuBar.

Nota

L'integrazione del menu globale non è supportata quando l'incorporamento del gioco è abilitato nell'editor. Per testare questa funzionalità durante l'esecuzione del progetto, assicurati di disabilitare l'incorporamento del gioco passando alla schermata Gioco, cliccando sull'icona più a destra nella barra in alto e deselezionando Incorpora gioco al prossimo avvio.

Usare decoratori lato client

Questo è supportato solo su macOS.

Molte applicazioni moderne utilizzano decorazioni lato client (CSD) anziché affidarsi al gestore delle finestre del sistema operativo per disegnare la barra del titolo e i bordi delle finestre (decorazioni lato server). Ciò consente un aspetto più personalizzabile e una migliore integrazione con l'interfaccia utente dell'applicazione.

Attualmente Godot supporta le decorazioni lato client solo su macOS. Queste si possono utilizzare abilitando l'impostazione del progetto display/window/size/extend_to_title.

Confronto tra le decorazioni standard di una finestra (in alto) e le decorazioni lato client (in basso) su macOS

Confronto tra le decorazioni standard di una finestra (in alto) e le decorazioni lato client (in basso) su macOS

Dopo aver abilitato le decorazioni lato client, il bordo della finestra non sarà più visualizzato e i pulsanti di minimizzazione/massimizzazione/chiusura appariranno come un overlay sull'applicazione. È necessario assicurarsi che l'applicazione fornisca un margine superiore sufficiente per visualizzare piacevolmente i pulsanti, e che il titolo della finestra sia visualizzato attraverso un nodo Label o simile.

Per adattare condizionalmente l'interfaccia utente in base all'abilitazione delle decorazioni lato client, usare DisplayServer.has_feature e verificare anche il valore attuale di Window.extend_to_title (che è ciò che l'impostazione del progetto modifica):

func _ready():
    if DisplayServer.has_feature(FEATURE_EXTEND_TO_TITLE) and get_window().extend_to_title:
        # Adjust UI for client-side decorations (a MarginContainer node
        # can be useful here). Also set the window title to be displayed
        # according to the native window title.
        $WindowTitle.visible = true
        $WindowTitle.text = get_window().title
        if OS.is_debug_build():
            $WindowTitle.text += " (DEBUG)"

Per posizionare correttamente il titolo della finestra, si consiglia di utilizzare DisplayServer.window_get_safe_title_margins() che restituisce un Vector3 in cui x rappresenta il margine sinistro, y il margine destro (che aumenterà se il sistema usa la composizione da destra a sinistra) e z l'altezza. Inoltre, è possibile chiamare DisplayServer.window_set_window_buttons_offset() per regolare la posizione dei pulsanti di chiusura/minimizzazione/massimizzazione (di solito per centrarli verticalmente).

Margini di sicurezza per il titolo quando si utilizzano decorazioni lato client su macOS

Margini di sicurezza per il titolo quando si utilizzano decorazioni lato client su macOS

Nota

Su macOS, le decorazioni lato client non sono supportate quando l'incorporamento del gioco è abilitato nell'editor. Per testare questa funzionalità durante l'esecuzione del progetto, assicurati di disabilitare l'incorporamento del gioco passando alla schermata Gioco, cliccando sull'icona più a destra nella barra in alto e deselezionando Incorpora gioco al prossimo avvio.

Visualizzare lo stato di avanzamento sulla barra delle applicazioni/Dock

Questo è supportato solo su Windows e macOS.

È possibile per le applicazioni segnalare al sistema operativo lo stato di avanzamento, e poi visualizzarlo sulla barra delle applicazioni o sull'icona nel Dock. Questo stato è composto da uno stato (attivo, in pausa, errore) e da una percentuale di completamento. Può essere utile per mostrare l'avanzamento anche quando l'utente non è concentrato sull'applicazione.

Visualizzare lo stato di avanzamento nel Dock su macOS

Visualizzare lo stato di avanzamento nel Dock su macOS

Questo si fa spesso sincronizzando l'avanzamento di un nodo ProgressBar con l'avanzamento segnalato al sistema operativo:

func set_progress(value, indeterminate = false):
    $ProgressBar.value = value
    $ProgressBar.indeterminate = indeterminate

    if $ProgressBar.indeterminate:
        get_window().set_taskbar_progress_state(DisplayServer.PROGRESS_STATE_INDETERMINATE)
    else:
        get_window().set_taskbar_progress_state(DisplayServer.PROGRESS_STATE_NORMAL)

    # The taskbar progress value must be between `0.0` and `1.0`
    # (values outside this range are clamped).
    # ProgressBar provides a `ratio` property that represents its current progress
    # as a value between `0.0` and `1.0`.
    get_window().set_taskbar_progress_value($ProgressBar.ratio)

Sono disponibili diversi stati di avanzamento: nessun avanzamento (nasconde la barra di avanzamento), indeterminato, normale, in pausa, errore. Consultare il riferimento classi per maggiori dettagli.

È possibile usare anche Window.request_attention() per far lampeggiare la finestra nella barra delle applicazioni (o farla rimbalzare nel Dock su macOS). Ad esempio, questo si può utilizzare per attirare l'attenzione dell'utente al termine di una lunga operazione.

Nota

Segnalare l'avanzamento non è supportato quando l'incorporamento del gioco è abilitato nell'editor. Per testare questa funzionalità durante l'esecuzione del progetto, assicurati di disabilitare l'incorporamento del gioco passando alla schermata Game, cliccando sull'icona più a destra nella barra in alto e deselezionando Embed Game on Next Play.

Inviare notifiche desktop

Attualmente Godot non offre supporto nativo per inviare notifiche sul desktop.

Tuttavia, su macOS e Linux, è possibile utilizzare rispettivamente le utilità da riga di comando osascript e notify-send per inviare notifiche sul desktop:

func send_notification(title, message):
    var app_name = ProjectSettings.get_setting("application/config/name")
    if app_name.is_empty():
        app_name = "Unnamed Project"

    if OS.has_feature("macos") and not OS.is_sandboxed():
        # Note that this will not work if the project is exported in sandbox mode
        # (e.g. for the Mac App Store).
        OS.execute("osascript", [
                "-e",
                'display notification \\"%s\\" with title \\"%s\\" subtitle \\"%s\\"' % [
                    message,
                    app_name,
                    title,
                ]
            ])
    elif OS.has_feature("linuxbsd"):
        OS.execute("notify-send", ["--app-name", app_name, title, message])

func _ready():
    send_notification("Success", "Operation completed successfully.")

Purtroppo, non esiste un'alternativa equivalente facilmente disponibile su Windows.

Memorizzare la posizione e le dimensioni della finestra tra le sessioni

Godot non offre un supporto integrato per memorizzare la posizione e le dimensioni delle finestre tra una sessione e l'altra, ma è possibile implementarlo manualmente tramite uno script. Un esempio di base che supporta configurazioni multi-monitor potrebbe essere un Autoload con questo script:

extends Node

# Use a dedicated configuration file for the window state.
# This way, the application's other configuration files are left
# untouched and can be put in version control without unnecessary diffs
# being produced.
const CONFIG_WINDOW_PATH = "user://window.ini"

var config_file = ConfigFile.new()


func _enter_tree():
    config_file.load(CONFIG_WINDOW_PATH)

    # Do not restore previous window state if running from the editor
    # with game embedding enabled.
    if not Engine.is_embedded_in_editor():
        var window_screen = config_file.get_value("main", "screen", -1)
        if window_screen is int:
            get_window().current_screen = window_screen

        var window_mode = config_file.get_value("main", "mode", -1)
        if window_mode is Window.Mode:
            get_window().mode = window_mode

        var window_position = config_file.get_value("main", "position", -1)
        if window_position is Vector2i:
            get_window().position = window_position

        var window_size = config_file.get_value("main", "size", -1)
        if window_size is Vector2i:
            get_window().size = window_size


func _exit_tree():
    # Save the current window state when the application is quit normally.
    # In a real world scenario, it's recommended to also save this information
    # regularly (e.g. with a Timer node), so that the window state can be
    # restored after a crash or when terminated externally.
    config_file.set_value("main", "screen", get_window().current_screen)
    config_file.set_value("main", "mode", get_window().mode)
    config_file.set_value("main", "position", get_window().position)
    config_file.set_value("main", "size", get_window().size)
    config_file.save(CONFIG_WINDOW_PATH)

Nota

L'esempio precedente tiene traccia solo della posizione della finestra principale. Nelle applicazioni che generano più finestre, sarà necessario salvare e caricare separatamente la posizione e le dimensioni di ciascuna finestra.

Nascondere la finestra durante la schermata di avvio

Per alcune applicazioni, potrebbe essere preferibile nascondere la schermata di avvio e visualizzarne una personalizzata con una barra di avanzamento (oppure non visualizzare alcuna schermata, se l'applicazione si avvia rapidamente).

Godot non offre un supporto nativo per nascondere la finestra durante la schermata di avvio, ma è possibile ottenere un risultato simile utilizzando una finestra trasparente molto piccola nelle impostazioni del progetto, e poi ridimensionando la finestra e disabilitando la trasparenza una volta caricata la scena principale.

Per fare ciò, è necessario configurare le impostazioni del progetto quanto segue:

Questo script si può usare come Autoload per ripristinare le impostazioni originali una volta terminata la visualizzazione della schermata di avvio:

extends Node


func _enter_tree():
    # Wait a frame to be rendered before restoring the window properties.
    # Otherwise, properties will be restored too early and the window border
    # will show up around a transparent window.
    await get_tree().process_frame

    get_viewport().transparent_bg = false
    get_window().transparent = false
    get_window().borderless = false
    get_window().size = Vector2i(1152, 648)

Visualizzare l'applicazione come overlay

È possibile visualizzare la finestra dell'applicazione come un overlay che rimane sempre sopra le altre finestre. Questo può essere utile per applicazioni come widget o monitor di sistema.

Per farlo, abilita tutte le seguenti impostazioni del progetto:

Ricorda di posizionare e ridimensionare la finestra tramite script, poiché una finestra senza bordi in genere non si può spostare dall'utente.

Per permette il passaggio dell'input del mouse all'applicazione nello sfondo, imposta la proprietà mouse_passthrough su true sulla finestra che è disegnata come overlay. È anche possibile definire un poligono in mouse_passthrough_polygon, in modo che determinate aree possano comunque intercettare l'input del mouse sull'overlay.

Inoltre, è possibile impostare la proprietà exclude_from_capture su true per impedire che l'overlay appaia negli screenshot o nelle registrazioni. Questo suggerimento è implementato solo su Windows e macOS ed è implementato fin quanto è possibile, pertanto non è affidabile come misura di sicurezza assoluta o DRM.

Nota

La visualizzazione come overlay non è supportata quando l'incorporamento del gioco è abilitato nell'editor. Per testare questa funzionalità durante l'esecuzione del progetto, assicurati di disabilitare l'incorporamento del gioco passando alla schermata Gioco, cliccando sull'icona più a destra nella barra in alto e deselezionando Incorpora gioco al prossimo avvio.

Inoltre, tieni presente che non è possibile visualizzare gli overlay sopra un'altra applicazione se quest'ultima utilizza la modalità a schermo intero esclusiva. Affinché gli overlay siano visibili, è necessario utilizzare la modalità a schermo intero senza bordi.

Esistono anche problemi noti con la visualizzazione di finestre trasparenti su Windows con configurazioni GPU ibride (come NVIDIA Optimus). Passare a un altro renderer potrebbe aiutare a risolvere il problema.

Su Linux con X11, la trasparenza non funzionerà se l'utente ha disabilitato la composizione nelle impostazioni del gestore delle finestre.

Adattare a schermi hiDPI

I display moderni variano moltissimo nella loro densità dei pixel, il che significa che spesso è necessario un fattore di scala diverso per garantire che gli elementi dell'interfaccia utente rimangano leggibili. È anche possibile impostare manualmente il fattore di scala dall'utente, in modo che l'applicazione rimanga comoda da usare.

Il supporto di Godot per risoluzioni multiple è ideale per applicazioni scalabili, se configurato correttamente. Segui le istruzioni nella sezione Applicazioni non di gioco della documentazione sulle risoluzioni multiple.

Nota

Attualmente Godot supporta la lettura del fattore di scala dello schermo dalle impostazioni del sistema operativo solo su macOS, Android e Linux (solo Wayland). Su Linux (X11) e Windows, sarà necessario fornire un'opzione di scala manuale per consentire all'utente di regolare la scala dell'interfaccia utente a piacere.

Integrazione del lettore dello schermo

I lettori dello schermo consentono alle persone ipovedenti di usare un'applicazione leggendo ad alta voce gli elementi dell'interfaccia utente e fornendo comandi di navigazione. I display Braille sono un altro approccio che si basa anch'esso sulle informazioni di accessibilità per funzionare correttamente.

Godot abilita automaticamente il supporto per i lettori dello schermo se ne rileva uno in esecuzione. È possibile configurare questa opzione nelle Impostazioni del progetto tramite accessibility/general/accessibility_support per disabilitarla quando non è desiderata. È possibile anche abilitarla forzatamente, il che è utile quando si utilizzano strumenti di debug per l'accessibilità che non sono riconosciuti come lettori dello schermo da Godot.

Godot utilizza la libreria AccessKit per l'integrazione con i lettori dello schermo.

Suggerimento

Poiché il supporto per i lettori dello schermo utilizza l'applicazione stessa per riprodurre l'audio (anziché il progetto Godot), funzionerà anche se il driver audio è impostato su Dummy nelle impostazioni del progetto, come descritto di seguito.

Si raccomanda vivamente di testare l'applicazione con i più diffusi lettori dello schermo sulle piattaforme di destinazione per garantire una buona esperienza utente agli utenti ipovedenti. Alcuni esempi includono NVDA su Windows, VoiceOver su macOS e Orca su Linux.

Per ottenere un buon livello di usabilità con i lettori di schermo, è necessario un lavoro molto considerevole. Bisogna definire le etichette di accessibilità attraverso le proprietà Control.accessibility_name e Control.accessibility_description, e assicurarsi che l'interfaccia utente segua un ordine logico quando viene letta da un lettore dello schermo.

Vedi anche

Consulta anche Sintetizzatore vocale per la funzionalità di sintesi vocale, che è separata dai lettori dello schermo.

Aggiungere test unitari

In un'applicazione, avere una configurazione di test unitari è spesso più utile rispetto a un gioco. Questo permette di individuare le regressioni in modo automatizzato, cosa che tende a essere più facile da fare in uno scenario applicativo in cui la logica può essere nettamente separata.

GDScript non include un framework integrato per i test unitari, ma esistono diverse estensioni per i test unitari gestiti dalla communità:

Con C# e GDExtension (C++, Rust, ecc.), è possibile utilizzare framework di test standard come NUnit o doctest.

Ottimizzare le dimensioni di distribuzione

Poiché le applicazioni non di gioco generalmente evitano di usare parti sostanziose del motore di gioco, come l'audio o le funzionalità 3D, è possibile compilare un modello di esportazione ottimizzato per ridurne le dimensioni del file. Ciò migliorerà anche i tempi di avvio, soprattutto sulla piattaforma web, dove le dimensioni del file binario sono direttamente correlate alla velocità di inizializzazione.

La riduzione delle dimensioni è spesso significativa (rispetto alle dimensioni del progetto), poiché le applicazioni contengono meno risorse enormi rispetto ai giochi. Consultare la documentazione Ottimizzare una compilazione per dimensioni per ulteriori informazioni su come procedere.

Creare una distribuzione con un singolo file eseguibile

Normalmente, Godot crea un file PCK contenente i dati del progetto nella stessa cartella dell'eseguibile. Ciò significa che se l'eseguibile viene spostato senza spostare anche il file PCK allo stesso tempo, l'applicazione non funzionerà. Questo non è ideale per le applicazioni, che sono sempre più spesso distribuite come un singolo file eseguibile.

Per rendere l'applicazione completamente autonoma e contenuta in un singolo file eseguibile, è possibile abilitare Incorpora PCK nelle opzioni predefinite di esportazione. In questo modo, i dati PCK verranno incorporati nell'eseguibile, così che l'applicazione si possa spostare senza problemi. Ciò permette anche di eseguire l'applicazione direttamente da un archivio ZIP senza doverlo prima estrarre.

Nota

L'incorporamento PCK ha una limitazione di dimensione a seconda della piattaforma. Le applicazioni molto grandi (parecchi GB) potrebbero non essere in grado di usare questa funzionalità su tutte le piattaforme. Consultare la documentazione di esportazione per la piattaforma interessata per ulteriori dettagli.

Creare applicazioni portatili

Un'applicazione è definita portatile quando la si può eseguire senza installazione e quando la sua configurazione è interamente contenuta nella cartella in cui è stata estratta. Ciò consente di copiare i file dell'applicazione su un'unità USB o simile, nonché di eseguirla su dispositivi diversi senza bisogno di un processo di installazione.

La modalità autonoma dell'editor Godot al momento non si può utilizzare all'interno dei progetti. Tuttavia, è comunque possibile salvare i propri file di configurazione nella cartella contenente l'eseguibile, facendo quanto segue:

var config_path = OS.get_executable_path().get_base_dir().path_join("config.ini")
# Then use `config_path` to save/load configuration files using ConfigFile or similar.

Si potrebbe voler rendere la modalità portatile opzionale, in quanto non è sempre desiderata. In genere, ciò si fa rilevando la presenza di un file specifico nella cartella dell'eseguibile (ad esempio, un file denominato portable.txt) e usando la cartella dell'eseguibile per la configurazione solo se tale file è presente.

Avvertimento

È importante notare che questo metodo funzionerà solo se l'applicazione è estratta in una posizione scrivibile. Ci saranno errori di autorizzazione se il file eseguibile viene avviato da una posizione di sola lettura, come ad esempio C:\Program Files su Windows.

Creare programmi di installazione

Mentre i giochi sono in genere installati tramite launcher come Steam o scaricati come file ZIP, le applicazioni sono spesso distribuite come programmi di installazione per una migliore integrazione con il desktop. Il programma di installazione può eseguire azioni come aggiungere collegamenti al menu Start o al desktop, configurare associazioni ai file e altro ancora. È inoltre possibile eseguire i programmi di installazione automaticamente tramite riga di comando, il che li rende più adatti agli ambienti aziendali.

Godot non offre un supporto integrato per creare programmi di installazione per i progetti esportati. Tuttavia, è comunque possibile creare i propri programmi di installazione attraverso strumenti di terze parti.

Ecco un elenco non esaustivo di strumenti che si possono usare per creare programmi di installazione:

  • Windows: Inno Setup, NSIS

    • Se si dispone di un certificato di firma del codice, è importante firmare sia il programma di installazione sia l'eseguibile del progetto. Per farlo, firmare l'eseguibile del progetto esportato, creare il programma di installazione contenente il progetto esportato, quindi firmare manualmente il programma di installazione appena creato.

  • macOS: create-dmg

  • Linux: Flatpak

    • Esiste una Godot BaseApp che può servire da base per la creazione di pacchetti Flatpak per i progetti in Godot. Consultare Pixelorama Flatpak per un esempio di Flatpak che utilizza questa BaseApp.

Risorse

Queste pagine descrivono le attività comunemente svolte in applicazioni non di gioco: