Exportando

Visão geral

Agora que você tem um jogo em funcionamento, provavelmente quer compartilhar seu sucesso com os outros. No entanto, não é prático pedir a seus amigos que façam o download do Godot apenas para que possam abrir seu projeto. Em vez disso, você pode exportar seu projeto, convertendo-o em um "pacote" que pode ser executado por qualquer pessoa.

A maneira como você exporta seu jogo depende de qual plataforma você está objetivando. Neste tutorial, você aprenderá como exportar o jogo "Dodge the Creeps" para uma variedade de plataformas. Primeiro, entretanto, precisamos fazer algumas mudanças na maneira como o jogo funciona.

Nota

Se você ainda não fez "Dodge the Creeps", leia :ref: doc_your_first_game antes de continuar com este tutorial.

Preparando o projeto

Em "Dodge the Creeps", usamos controles de teclado para mover o personagem do jogador. Isso é bom se o seu jogo está sendo jogado em uma plataforma de PC, mas em um telefone ou tablet, você precisa suportar a entrada de tela sensível ao toque. Como um evento de clique pode ser tratado da mesma forma que um evento de toque, convertemos o jogo em um estilo de entrada de clicar-e-mover.

Por padrão, o Godot emula o mouse quando há entrada de toque. Quer dizer que se tudo é programado para acontecer em um evento de mouse, o toque vai ativar da mesma forma. O Godot também pode emular o toque a partir de cliques do mouse, o que precisaremos para poder jogar nosso jogo no computador depois que trocarmos para entrada de toque.

Em Projeto > Configurações do Projeto, abaixo de Input Devices>Pointing, ative Emulate Mouse From Touch.

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

Como já estamos nas configurações de Janela, também devemos definir em Handheld a Orientação para portrait.

../../_images/export_handheld_stretchsettings.png

Em seguida, precisamos modificar o script Player.gd para alterar o método de entrada. Removeremos as entradas principais e faremos com que o jogador se mova em direção a um "alvo" definido pelo evento de toque (ou clique).

Aqui está o script completo para o jogador, com comentários observando o que mudamos:

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);
    }
}

Definindo uma cena principal

A cena principal é aquela na qual o seu jogo iniciará. Para este exemplo de Dodge the Creeps, em Projeto -> Configurações do Projeto -> Aplicação -> Rodar, defina Cena Principal para Main.tscn clicando no ícone da pasta e selecionando-a.

Modelos de exportação

Para exportar, você precisa baixar os modelos de exportação a partir de http://godotengine.org/download. Esses modelos são versões otimizadas da engine sem o editor pré-compilado para cada plataforma. Você também pode baixá-los pelo Godot clicando em Editor -> Gerenciar Modelos de Exportação:

../../_images/export_template_menu.png

Nota

Se você baixou Godot pela Steam, os modelos de exportação já estão incluídos. Portanto, você não precisa baixá-los usando a caixa de diálogo Gerenciar modelos de exportação.

Na janela que aparecer, você pode clicar em Download para obter a versão do modelo que corresponde à sua versão do Godot.

../../_images/export_template_manager.png

Nota

Os modelos de exportação são vinculados a uma versão específica do Godot. Se você atualizar o Godot, você deve baixar os modelos que correspondem à nova versão.

Predefinições de Exportação

Em seguida, você pode definir as configurações de exportação clicando em Projeto -> Exportar.

Crie uma nova predefinição de exportação clicando em Adicionar ... e selecionando uma plataforma. Você pode fazer quantas predefinições desejar com configurações diferentes.

../../_images/export_presets_window.png

Na parte inferior da janela há dois botões. Exportar PCK/ZIP cria apenas uma versão compactada dos dados do seu projeto. Isso não inclui um executável, portanto, o projeto não pode ser executado por conta própria.

O segundo botão, Exportar Projeto, cria uma versão executável completa do seu jogo, como um .apk para o Android ou um .exe para o Windows.

Nas abas Recursos e Funcionalidades você pode personalizar como o jogo é exportado para cada plataforma. Podemos deixar essas configurações como estão por enquanto.

Exportando por plataforma

Nesta seção, vamos percorrer o processo de cada plataforma, incluindo qualquer software ou requisitos adicionais que você precise.

PC (Linux/MacOS/Windows)

A exportação de plataformas para PC funciona da mesma forma nos três sistemas operacionais suportados. Abra a janela de exportação e clique em Adicionar... para criar a(s) predefinição(ões) que você deseja criar. Em seguida, clique em Exportar Projeto e escolha um nome e uma pasta de destino. Escolha um local fora da pasta do seu projeto.

Clique em Salvar e o motor criará os arquivos de exportação.

Nota

Ao exportar para o macOS, se você exportar em um computador macOS, você terminará com um arquivo .dmg, enquanto se usar um Linux ou Windows para isso produzirá um .zip. Em ambos os casos, o arquivo compactado contém um .app do macOS que você pode clicar duas vezes e executar.

Nota

No Windows, se você deseja que o executável exportado tenha um ícone diferente do padrão, será necessário alterá-lo manualmente. Veja Alterando o ícone do aplicativo para Windows.

Android

Dica

Os dispositivos móveis vêm com uma ampla variedade de recursos. Na maioria dos casos, as configurações padrão do Godot funcionarão, mas o desenvolvimento móvel às vezes é mais arte do que ciência, e você pode precisar fazer algumas experiências e procurar ajuda para fazer tudo funcionar.

Antes de exportar seu projeto para Android, você deve fazer o download do seguinte software:

Quando você executar o Android Studio pela primeira vez, clique em Configure -> SDK Manager e instale Android SDK Platform Tools. Isso instala a ferramenta de linha de comando adb que o Godot usa para se comunicar com o seu dispositivo.

Em seguida, crie um keystore de depuração executando o seguinte comando na linha de comandos do seu sistema:

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

Clique em Editor -> Configurações do Editor no Godot e selecione a seção Export/Android. Aqui, você precisa definir os caminhos para os aplicativos do Android SDK em seu sistema e o local do keystore que você acabou de criar.

../../_images/export_editor_android_settings.png

Agora você está pronto para exportar. Clique em Projeto -> Exportar e adicione uma predefinição para Android (veja acima). Selecione as predefinições para Android. Em Opções vá para Screen e mude Orientation para Portrait. Se seu jogo estiver no modo paisagem (ou seja, a largura da janela em pixels é maior que a altura da janela), deixe esta opção em Landscape.

Clique no botão Exportar Projeto e o Godot criará um APK que você pode baixar no seu dispositivo. Para fazer isso na linha de comando, use o seguinte:

adb install dodge.apk

Nota

Seu dispositivo pode precisar estar no modo de desenvolvedor. Consulte a documentação do seu dispositivo para detalhes.

Se o seu sistema for compatível, a conexão de um dispositivo Android compatível fará com que um botão Implantação com um clique apareça na área de botões de teste de jogo (playtest) do Godot:

../../_images/export_android_oneclick.png

Clicar neste botão cria o APK e o copia para o seu dispositivo em uma única etapa.

iOS

Nota

Para compilar seu jogo para iOS, você deve ter um computador executando o macOS com o Xcode instalado.

Antes de exportar, existem algumas configurações que você deve concluir para o projeto exportar com êxito. Primeiro, o App Store Team Id, que você pode encontrar fazendo login na sua conta de desenvolvedor da Apple e procurando na seção Membership.

Você também deve fornecer ícones e imagens da tela inicial, conforme mostrado abaixo:

../../_images/export_ios_settings.png

Clique em Exportar Projeto e selecione uma pasta de destino.

Depois de exportar o projeto com sucesso, você verá que as seguintes pastas e arquivos foram criados no local selecionado:

../../_images/export_xcode_project_folders.png

Agora você pode abrir o projeto no Xcode e criar o projeto para iOS. O procedimento de compilação do Xcode está além do escopo deste tutorial. Consulte https://help.apple.com/xcode/mac/current/#/devc8c2a6be1 para mais informações.

HTML5 (web)

Clique em Exportar Projeto na predefinição HTML5. Não precisamos alterar nenhuma das configurações padrão.

Quando a exportação estiver concluída, você terá uma pasta contendo os seguintes arquivos:

../../_images/export_web_files.png

Visualizar o arquivo .html no seu navegador permite que você abra o jogo. No entanto, você não pode abrir o arquivo diretamente, é necessário que ele seja disponibilizado por um servidor web. Se você não tiver um em seu computador, pesquise na internet sugestões para seu SO específico.

Aponte seu navegador para a URL onde você colocou o arquivo HTML. Você pode ter que esperar alguns momentos enquanto o jogo carrega antes que você veja a tela inicial.

../../_images/export_web_example.png

A janela do console abaixo do jogo o informa se algo der errado. Você pode desabilitá-la desativando Exportar Com Depuração na caixa de diálogo do arquivo final que aparece quando você exporta o projeto.

../../_images/export_web_export_with_debug_disabled.png

Nota

Apesar do WebAssembly ter suporte na maioria dos navegadores, ainda é uma tecnologia emergente e você pode encontrar algumas coisas que ainda não funcionam. Certifique-se de ter atualizado seu navegador para a versão mais recente, e relate quaisquer erros que você encontrar no repositório do Godot no Github.