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 a 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. A 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

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.