Esportazione

Panoramica

Ora che avete un gioco funzionante, probabilmente volete condividere il vostro successo con gli altri. Tuttavia, non è pratico chiedere ai tuoi amici di scaricare Godot solo per aprire il tuo progetto. Invece, puoi esportare il tuo progetto, convertendolo in un "pacchetto" che può essere gestito da chiunque.

La modalità di esportazione del gioco dipende dalla piattaforma di destinazione. In questo tutorial, imparerai come esportare il gioco "Dodge the Creeps" per una varietà di esse. In primo luogo, tuttavia, abbiamo bisogno di apportare modifiche ad alcune funzionalità del gioco.

Nota

Se non hai ancora creato "Dodge the Creeps", leggi :ref:'doc_your_first_game' prima di continuare con questo tutorial.

Preparazione del progetto

In "Dodge the Creeps" abbiamo usato i controlli della tastiera per muovere il giocatore. Questo va bene su una PC, ma su un telefono o tablet è necessario rilevare l'input da touchscreen. Poiché un evento click può essere trattato allo stesso modo di un evento touch, convertiremo il gioco in uno stile di input click-and-move.

Di default Godot emula l'input del mouse dall'input touch. Ciò significa che se qualcosa viene codificato per attivarsi con un evento del mouse, anche l'input touch lo attiverà. Godot può anche emulare l'input touch dal clic del mouse, del quale ne avremo bisogno per essere in grado di continuare a giocare sul nostro computer dopo che passeremo all'input touch. In "Impostazioni progetto" in Dispositivi di input e Puntamento, imposta Emula touch dal mouse su "Attivo".

../../_images/export_touchsettings.png

Vogliamo anche assicurarci che il gioco sia in scala costante su schermi di dimensioni diverse, quindi nelle impostazioni del progetto andate su Visualizza, poi cliccate su Finestra. Nelle opzioni Stretch, impostare Mode su "2d" e Aspect su "keep".

Dato che siamo già nelle impostazioni Finestra, dovremmo anche impostare sotto Manuale l'Orientamento su "ritratto".

../../_images/export_handheld_stretchsettings.png

Successivamente, è necessario modificare lo script ''Player.gd'' per modificare il metodo di input. Rimuoveremo gli input dei tasti e faremo in modo che il giocatore si sposti verso un "bersaglio" impostato dall'evento touch (o click).

Ecco lo script completo per il giocatore, con i commenti che indicano i cambiamenti effettuati:

extends Area2D

signal hit

export var speed = 400
var screen_size
# Add this variable to hold the clicked position.
var target = Vector2()

func _ready():
    hide()
    screen_size = get_viewport_rect().size

func start(pos):
    position = pos
    # Initial target is the start position.
    target = pos
    show()
    $CollisionShape2D.disabled = false

# Change the target whenever a touch event happens.
func _input(event):
    if event is InputEventScreenTouch and event.pressed:
        target = event.position

func _process(delta):
    var velocity = Vector2()
    # Move towards the target and stop when close.
    if position.distance_to(target) > 10:
        velocity = target - position

# Remove keyboard controls.
#    if Input.is_action_pressed("ui_right"):
#       velocity.x += 1
#    if Input.is_action_pressed("ui_left"):
#        velocity.x -= 1
#    if Input.is_action_pressed("ui_down"):
#        velocity.y += 1
#    if Input.is_action_pressed("ui_up"):
#        velocity.y -= 1

    if velocity.length() > 0:
        velocity = velocity.normalized() * speed
        $AnimatedSprite.play()
    else:
        $AnimatedSprite.stop()

    position += velocity * delta
    # We still need to clamp the player's position here because on devices that don't
    # match your game's aspect ratio, Godot will try to maintain it as much as possible
    # by creating black borders, if necessary.
    # Without clamp(), the player would be able to move under those borders.
    position.x = clamp(position.x, 0, screen_size.x)
    position.y = clamp(position.y, 0, screen_size.y)

    if velocity.x != 0:
        $AnimatedSprite.animation = "walk"
        $AnimatedSprite.flip_v = false
        $AnimatedSprite.flip_h = velocity.x < 0
    elif velocity.y != 0:
        $AnimatedSprite.animation = "up"
        $AnimatedSprite.flip_v = velocity.y > 0

func _on_Player_body_entered( body ):
    hide()
    emit_signal("hit")
    $CollisionShape2D.set_deferred("disabled", true)
using Godot;
using System;

public class Player : Area2D
{
    [Signal]
    public delegate void Hit();

    [Export]
    public int Speed = 400;

    private Vector2 _screenSize;
    // Add this variable to hold the clicked position.
    private Vector2 _target;

    public override void _Ready()
    {
        Hide();
        _screenSize = GetViewport().Size;
    }

    public void Start(Vector2 pos)
    {
        Position = pos;
        // Initial target us the start position.
        _target = pos;
        Show();
        GetNode<CollisionShape2D>("CollisionShape2D").Disabled = false;
    }

    // Change the target whenever a touch event happens.
    public override void _Input(InputEvent @event)
    {
        if (@event is InputEventScreenTouch eventMouseButton && eventMouseButton.Pressed)
        {
            _target = (@event as InputEventScreenTouch).Position;
        }
    }

    public override void _Process(float delta)
    {
        var velocity = new Vector2();
        // Move towards the target and stop when close.
        if (Position.DistanceTo(_target) > 10)
        {
            velocity = _target - Position;
        }

        // Remove keyboard controls.
        //if (Input.IsActionPressed("ui_right"))
        //{
        //    velocity.x += 1;
        //}

        //if (Input.IsActionPressed("ui_left"))
        //{
        //    velocity.x -= 1;
        //}

        //if (Input.IsActionPressed("ui_down"))
        //{
        //    velocity.y += 1;
        //}

        //if (Input.IsActionPressed("ui_up"))
        //{
        //    velocity.y -= 1;
        //}

        var animatedSprite = GetNode<AnimatedSprite>("AnimatedSprite");

        if (velocity.Length() > 0)
        {
            velocity = velocity.Normalized() * Speed;
            animatedSprite.Play();
        }
        else
        {
            animatedSprite.Stop();
        }

        Position += velocity * delta;
        // We still need to clamp the player's position here because on devices that don't
        // match your game's aspect ratio, Godot will try to maintain it as much as possible
        // by creating black borders, if necessary.
        // Without clamp(), the player would be able to move under those borders.
        Position = new Vector2(
            x: Mathf.Clamp(Position.x, 0, _screenSize.x),
            y: Mathf.Clamp(Position.y, 0, _screenSize.y)
        );

        if (velocity.x != 0)
        {
            animatedSprite.Animation = "walk";
            animatedSprite.FlipV = false;
            animatedSprite.FlipH = velocity.x < 0;
        }
        else if(velocity.y != 0)
        {
            animatedSprite.Animation = "up";
            animatedSprite.FlipV = velocity.y > 0;
        }
    }
    public void OnPlayerBodyEntered(PhysicsBody2D body)
    {
        Hide(); // Player disappears after being hit.
        EmitSignal("Hit");
        GetNode<CollisionShape2D>("CollisionShape2D").SetDeferred("disabled", true);
    }
}

Impostare una scena principale

La scena radice è la scena da cui il gioco si avvia. In Progetto -> Impostazioni Progetto -> Applicazione -> Esegui, imposta Main Scene a "Main.tscn" cliccando l'icona della cartella e selezionandola.

Modelli di esportazione

Per esportare, è necessario scaricare i modelli di esportazione da http://godotengine.org/download. Questi modelli sono versioni ottimizzate del motore senza l'editor precompilato per ogni piattaforma. È anche possibile scaricarli in Godot facendo clic su "Editor" - - - > Gestisci modelli di esportazione:

../../_images/export_template_menu.png

Nella finestra che appare, puoi cliccare su "Download" per ottenere la versione del modello che corrisponde alla tua versione di Godot.

../../_images/export_template_manager.png

Nota

Se si aggiorna Godot, è necessario scaricare i modelli relativi alla nuova versione o i progetti esportati potrebbero non funzionare correttamente.

Export presets (Profili di esportazione)

Successivamente, è possibile configurare le impostazioni di esportazione facendo clic su * Progetto -> Esporta *.

Crea un nuovo pofilo di esportazione cliccando su "Add....." e selezionando una piattaforma. È possibile creare più profili a piacere con impostazioni diverse.

../../_images/export_presets_window.png

Nella parte inferiore della finestra sono presenti due pulsanti. "Esporta PCK / ZIP" crea solo una versione compressa dei dati del progetto. Questo non include alcun eseguibile, quindi il progetto non può girare in autonomia.

Il secondo pulsante, "Esporta progetto", crea una versione eseguibile completa del gioco, ad esempio un '.apk' per Android o un '.exe' per Windows.

Nelle schede "Risorse" e "Caratteristiche" è possibile personalizzare le modalità di esportazione del gioco per ogni piattaforma. Per ora possiamo lasciare queste impostazioni come sono.

Esportazione per piattaforma

In questa sezione, affronteremo il procedimento per ogni piattaforma, includendo eventuale software o requisiti necessari.

PC (Linux/macOS/Windows)

L'esportazione su PC è la stessa per tuttu e tre i sistemi operativi supportati. Apri la finestra di esportazione e clicca su "Add....." per creare i preset che desideri. Quindi fai clic su "Esporta progetto" e scegli un nome e una cartella di destinazione. Scegli una posizione al di fuori dalla cartella del progetto.

Fare clic su "Salva" e l'engine creerà i file relativi all'esportazione.

Nota

Quando esporti per macOS, tramite un computer macOS, otterrai un file '.dmg', mentre se usi Linux o Windows otterrai un file '.zip'. In entrambi i casi, il file compresso contiene un .app per macOS che è possibile eseguire con un doppio click.

Nota

In Windows, se si desidera che l'eseguibile esportato abbia un'icona diversa da quella predefinita, è necessario modificarla manualmente. Vedere: Changing application icon for Windows.

Android

Suggerimento

I dispositivi mobili sono dotati di un'ampia gamma di funzionalità. Nella maggior parte dei casi basteranno le impostazioni predefinite di Godot, ma lo sviluppo mobile a volte è più estroso, quindi potrebbe essere necessario fare tentativi e cercare aiuto per farlo funzionare.

Prima di poter esportare il progetto per Android, è necessario scaricare il seguente software:

Quando si esegue Android Studio per la prima volta, fare clic su Configura -> SDK Manager e installare "Android SDK Platform Tools". Questo installa lo strumento a riga di comando adb che Godot usa per comunicare con il vostro dispositivo.

Successivamente, creare un keystore di debug eseguendo il seguente comando sulla riga di comando del sistema:

keytool -keyalg RSA -genkeypair -alias androiddebugkey -keypass android -keystore debug.keystore -storepass android -dname "CN=Android Debug,O=Android,C=US" -validity 9999

Clicca su Editor -> Impostazioni Editor in Godot e seleziona la sezione Esporta/Android. Qui è necessario impostare i percorsi delle applicazioni SDK Android sul sistema e la posizione del keystore appena creato.

../../_images/export_editor_android_settings.png

Ora sei pronto per l'esportazione. Clicca su Project -> Export e aggiungi un preset per Android (vedi sopra). Seleziona i preset per Android e sotto Opzioni vai su Schermo e imposta Orientamento su "Ritratto".

Clicca sul pulsante "Export Project" e Godot costruirà un APK che potrai scaricare sul tuo dispositivo. Per farlo sulla riga di comando, utilizzare quanto segue:

adb install dodge.apk

Nota

Potrebbe essere necessario che il dispositivo sia in modalità sviluppatore. Consultare la documentazione del dispositivo per i dettagli.

Se il vostro sistema lo supporta, il collegamento di un dispositivo Android compatibile farà apparire il pulsante "One-click Deploy" nell'area del pulsante playtest di Godot:

../../_images/export_android_oneclick.png

Facendo clic su questo pulsante si crea l'APK e lo copia sul dispositivo in un unico passaggio.

iOS

Nota

Per costruire il tuo gioco per iOS, devi avere un computer che esegue macOS con Xcode installato.

Prima dell'esportazione, è necessario completare alcune impostazioni per la corretta esportazione del progetto. In primo luogo, ''l'Id team dell'App Store", che puoi trovare accedendo al tuo account sviluppatore Apple e cercando nella sezione "Appartenenza".

È inoltre necessario fornire icone e immagini della schermata iniziale come mostrato di seguito:

../../_images/export_ios_settings.png

Fare clic su "Esporta progetto" e selezionare una cartella di destinazione.

Una volta esportato correttamente il progetto, troverai le seguenti cartelle e file creati nella posizione selezionata:

../../_images/export_xcode_project_folders.png

Ora è possibile aprire il progetto in Xcode e costruire il progetto per iOS. La procedura di compilazione di Xcode va oltre lo scopo di questo tutorial. Visionare https://help.apple.com/xcode/mac/current/#/devc8c2a6be1 per ulteriori informazioni.

HTML5 (web)

Fare clic su "Esporta progetto" sul preset HTML5. Non è necessario modificare le impostazioni predefinite.

Al termine dell'esportazione, avrai una cartella contenente i seguenti file:

../../_images/export_web_files.png

La visualizzazione del file .html nel tuo browser ti permette di giocare. Tuttavia, non è possibile aprire il file direttamente, deve essere servito da un server web. Se non ne hai uno impostato sul tuo computer, puoi cercare online per trovare suggerimenti per il tuo specifico sistema operativo.

Usa il tuo browser per aprire l'indirizzo URL del file html. Il caricamento potrebbe impiegare qualche secondo prima di mostrare la schermata d'avvio.

../../_images/export_web_example.png

La finestra della console sotto il gioco ti dice se qualcosa va storto. È possibile disabilitarla impostando "Esporta con debug" su off quando si esporta il progetto.

../../_images/export_web_export_with_debug_disabled.png

Nota

While WASM is supported in all major browsers, it is still an emerging technology and you may find some things that don't work. Make sure you have updated your browser to the most recent version, and report any bugs you find at the Godot GitHub repository.