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.

By default Godot emulates mouse input from touch input. That means if anything is coded to happen on a mouse event, touch will trigger it as well. Godot can also emulate touch input from mouse clicks, which we will need to be able to keep playing our game on our computer after we switch to touch input. In the «Project Settings» under Input Devices and Pointing, set Emulate Touch From Mouse to «On».

../../_images/export_touchsettings.png

We also want to ensure that the game scales consistently on different-sized screens, so in the project settings go to Display, then click on Window. In the Stretch options, set Mode to «2d» and Aspect to «keep».

Since we are already in the Window settings, we should also set under Handheld the Orientation to «portrait».

../../_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);
    }
}

Setting a main scene

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, è possibile fare clic su «Download» per ottenere la versione del modello relativa alla 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)

Next, you can configure the export settings by clicking on Project -> Export.

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

Now you’re ready to export. Click on Project -> Export and add a preset for Android (see above). Select the Android Presets and under Options go to Screen and set Orientation to «Portrait».

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

Viewing the .html file in your browser lets you play the game. However, you can’t open the file directly, it needs to be served by a web server. If you don’t have one set up on your computer, you can search online to find suggestions for your specific OS.

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.