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.

Também queremos ter certeza que o jogo mudará de tamanho consistentemente em telas de diferentes tamanhos, então nas configurações do projeto vá para Display e clique em Window. Nas opções de Stretch, mude Mode para 2d e Aspect para keep.

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

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:

GDScript

C#

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:

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.

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.

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:

• Android SDK: https://developer.android.com/studio/

• Open JDK(a versão 8 é necessária, versões mais recentes não funcionarão): https://adoptopenjdk.net/index.html

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.

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:

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:

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:

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:

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.

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.

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.