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 Il tuo primo gioco 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 un PC, ma su un telefono o tablet è necessario rilevare l'input dal touchscreen. Poiché un evento click può essere trattato allo stesso modo di un evento touch, convertiremo il gioco in uno stile di input adatto a dispositivi mobili.

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 Project > Project Settings, under Input Devices > Pointing, enable Emulate Touch From Mouse.

../../_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.

Dato che siamo già nelle impostazioni Finestra, dobbiamo anche impostare nella sezione Manuale l'opzione 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. Per questo esempio Dodge the Creeps, in Progetto -> Impostazioni Progetto -> Applicazione -> Esegui, imposta Main Scene a Main.tscn cliccando l'icona della cartella e selezionandola.

Modelli di esportazione

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

../../_images/export_template_menu.png

Nota

Se hai scaricato Godot da Steam, i modelli di esportazione sono già inclusi. Pertanto, non hai bisogno di scaricarli dalla finestra di dialogo Manage Export Templates.

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

../../_images/export_template_manager.png

Nota

I modelli di esportazione sono legati ad una specifica versione di Godot. Se aggiorni Godot, devi scaricare i modelli che corrispondono alla nuova versione.

Export presets (Profili di esportazione)

Dopo, puoi configurare le impostazioni di esportazione facendo clic su Progetto -> Esporta.

Create a new export preset by clicking Add... and selecting a platform. You can make as many presets as you like with different settings.

../../_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. Non includerà alcun eseguibile, quindi il progetto non può essere eseguito in autonomia.

Il secondo pulsante, Esporta progetto, crea una versione eseguibile completa del gioco, come 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)

Exporting PC platforms works the same across the three supported operating systems. Open the export window and click Add... to create the preset(s) you want to make. Then click Export Project and choose a name and destination folder. Choose a location outside of your project folder.

Click Save and the engine will build the export files.

Nota

When exporting for macOS, if you export from a macOS computer, you'll end up with a .dmg file, while using Linux or Windows produces a .zip. In either case, the compressed file contains a macOS .app that you can double-click and run.

Nota

On Windows, if you want your exported executable to have a different icon than the default one, you need to change it manually. See 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:

When you run Android Studio for the first time, click on Configure -> SDK Manager and install Android SDK Platform Tools. This installs the adb command-line tool that Godot uses to communicate with your device.

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 newly added Android preset. Under Options, go to Screen and set Orientation to Portrait. If your game is in landscape mode (i.e. the window width in pixels is greater than the window height), leave this on Landscape.

Click the Export Project button and Godot will build an APK you can download on your device. To do this on the command line, use the following:

adb install dodge.apk

Nota

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

If your system supports it, connecting a compatible Android device will cause a One-click Deploy button to appear in Godot's playtest button area:

../../_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

To build your game for iOS, you must have a computer running macOS with Xcode installed.

Before exporting, there are some settings that you must complete for the project to export successfully. First, the App Store Team Id, which you can find by logging in to your Apple developer account and looking in the Membership section.

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

../../_images/export_ios_settings.png

Click Export Project and select a destination folder.

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

../../_images/export_xcode_project_folders.png

You can now open the project in Xcode and build the project for iOS. The Xcode build procedure is beyond the scope of this tutorial. See https://help.apple.com/xcode/mac/current/#/devc8c2a6be1 for more information.

HTML5 (web)

Click Export Project on the HTML5 preset. We don't need to change any of the default settings.

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. Instead, 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.

Point your browser at the URL where you've placed the HTML file. You may have to wait a few moments while the game loads before you see the start screen.

../../_images/export_web_example.png

The console window beneath the game tells you if anything goes wrong. You can disable it by disabling Export With Debug in the final file dialog that appears when you export the project.

../../_images/export_web_export_with_debug_disabled.png

Nota

While WebAssembly 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 on the Godot GitHub repository.