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.

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.

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 previamente compilado para cada plataforma. Você também pode baixá-los em Godot clicando em Editor -> Gerenciar Modelos de Exportação:

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

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.

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:
- 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 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:

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

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.

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.