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ê mesmo ainda não fez "Dodge the Creeps", por favor leia Seu primeiro jogo 2D 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:
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.