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, no entanto, 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. Nas "Configurações do Projeto" em Input Devices e Pointing, ligue a opção Emulate Touch From Mouse.

../../_images/export_touchsettings.png

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".

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

../../_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 é na qual o seu jogo iniciará. Em Projeto -> Opções do Projeto -> Aplicação -> Rodar, defina Cena Principal para "Main.tscn" clicando no ícone da pasta e selecionando-a.

Exportar modelos

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

../../_images/export_template_menu.png

Na janela que aparece, 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

Se você atualizar o Godot, deverá baixar modelos que correspondam à nova versão ou seus projetos exportados podem não funcionar corretamente.

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 mecanismo 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:: ref: doc_changing_application_icon_for_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 e em Opções vá para Screen e mude Orientation para "Portrait".

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, 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 sistema operacional 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 de ver a tela inicial.

../../_images/export_web_example.png

A janela do console abaixo do jogo informa se algo está errado. Você pode desativá-la configurando "Exportar Com Depuração" quando exportar o projeto.

../../_images/export_web_export_with_debug_disabled.png

Nota

Apesar de WASM 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.