html
Copiar
Editar

Como Criar Seu Primeiro Jogo no Android Studio: Guia para Jovens Desenvolvedores

Você já imaginou desenvolver seu próprio jogo para Android, compartilhá-lo com amigos e até ganhar experiência para futuras oportunidades? Com este guia completo, você vai aprender passo a passo como criar seu primeiro jogo no Android Studio, mesmo que nunca tenha programado antes. Preparado para transformar ideias em pixels? Então, vamos começar!

1. Introdução ao Mundo dos Jogos Android

Os smartphones Android dominam o mercado de dispositivos móveis, oferecendo um público gigantesco para quem deseja desenvolver jogos. Seja um jogo simples de plataforma ou um puzzle viciante, as possibilidades são quase infinitas. Neste tutorial, vamos utilizar Android Studio – a IDE oficial do Google para desenvolvimento Android – combinada com libGDX, um framework poderoso e flexível para criação de jogos em Java. Essa combinação é ideal para iniciantes, pois reúne recursos robustos e uma comunidade ativa.

Antes de mergulhar na parte prática, vamos entender por que escolher o Android Studio e o libGDX:

• Android Studio: IDE oficial do Google. Possui editor de código avançado, emulador integrado e suporte total a bibliotecas externas.
• libGDX: Framework open source em Java para desenvolvimento de jogos que funciona em Android, iOS, Desktop e Web. Fácil de configurar e com documentação completa.

2. Pré-requisitos e Ferramentas Necessárias

Antes de começar, certifique-se de ter o seguinte instalado em seu computador:

• Android Studio (versão mais recente).
• Java Development Kit (JDK) 8 ou superior. O libGDX funciona com Java 8, mas recomenda-se Java 11 para compatibilidade futura.
• Computador com pelo menos 8 GB de RAM (ideal para emular dispositivos e compilar projetos grandes).
• Conexão à internet para baixar bibliotecas, criar projetos e consultar documentações.
• Editor de imagens simples (como Krita ou GIMP) para criar ou editar sprites e ícones.

Após instalar o Android Studio e o JDK, abra o Android Studio e siga as configurações iniciais. Se for a primeira vez, a IDE solicitará que você faça login com sua conta Google e instale componentes adicionais, como o SDK do Android e ferramentas de build (Gradle). Esse processo pode levar alguns minutos, dependendo da velocidade de sua conexão.

3. Configurando o Projeto libGDX

Embora seja possível criar um jogo “do zero” apenas com código Android, o libGDX oferece uma série de facilidades, como gerenciamento de tela, renderização gráfica e detecção de toques. Veja como configurar um novo projeto:

1. Baixar o Setup Tool do libGDX: Acesse página oficial do libGDX e faça o download do gerador de projetos (gdx-setup.jar).
2. Executar o gerador de projetos: Abra o terminal (ou prompt de comando) e navegue até a pasta onde está o gdx-setup.jar. Execute o comando:

   java -jar gdx-setup.jar

3. Preencher informações do projeto no gerador:
   • Name: PrimeiroJogoAndroid
   • Package: com.seunome.primeirojogo
   • Game class: JogoMain (pode ser outro nome, mas sugerimos algo intuitivo)
   • Destination: caminho onde o projeto será salvo (por exemplo, C:\Projetos\PrimeiroJogoAndroid)
   • Android SDK: selecione a pasta onde está instalado o SDK do Android pelo Android Studio (geralmente em C:\Users\SeuUsuário\AppData\Local\Android\Sdk no Windows)
   • Sub-Projects: marque Android, Desktop e Core. Se quiser compilar também para iOS e HTML, selecione iOS e HTML; porém, para simplificar, começaremos apenas com Android e Desktop.
   • Extensions: reserve para adicionar mais tarde; inicialmente, mantenha as opções padrão.
4. Clique em “Generate” para criar a estrutura de projeto. O libGDX vai gerar um projeto multi-módulo usando Gradle como sistema de compilação.

Ao finalizar, abra o Android Studio e selecione “Open an existing Android Studio project”. Navegue até a pasta do seu projeto (por exemplo, PrimeiroJogoAndroid) e abra o arquivo build.gradle que fica na raiz.

4. Estrutura de Pastas do Projeto

O projeto gerado possui três módulos principais:

• core: onde ficará a maior parte do código do jogo (lógica, assets, renderização). Esse módulo é multiplataforma, ou seja, funciona tanto em Android quanto em Desktop.
• android: contém a configuração específica para compilar e executar no Android (manifesto, ícones, permissões).
• desktop: módulo para executar a versão Desktop do jogo, útil para testes rápidos antes de rodar no emulador ou aparelho.

Dentro do módulo core, você encontrará a classe principal criada (por exemplo, JogoMain.java) e uma pasta assets no caminho core/assets, onde serão colocados arquivos como imagens, sons, fontes e outros recursos.

5. Estrutura Básica de um Jogo libGDX

No libGDX, a classe principal do jogo geralmente implementa a interface ApplicationListener ou estende Game. A diferença é que, ao usar Game, você pode gerenciar várias telas (menus, gameplay, tela de game over), enquanto o ApplicationListener é mais indicado para protótipos simples.

Vamos usar Game para ter uma estrutura mais flexível:

package com.seunome.primeirojogo;

import com.badlogic.gdx.Game;
import com.seunome.primeirojogo.telas.TelaJogo;

public class JogoMain extends Game {

    @Override
    public void create() {
        // Definimos a tela inicial do jogo (por exemplo, TelaJogo)
        setScreen(new TelaJogo(this));
    }

    @Override
    public void render() {
        super.render(); // Fundamental para que o libGDX chame render() na tela atual
    }

    @Override
    public void dispose() {
        super.dispose();
    }
}

Note que criamos ou vamos criar a classe TelaJogo dentro do pacote com.seunome.primeirojogo.telas. Ela será responsável pelo ciclo principal do jogo (renderizar sprites, atualizar lógica, detectar toques). A seguir, veja como estruturá-la.

6. Implementando a Tela Principal do Jogo (TelaJogo)

Dentro do módulo core, crie o pacote com.seunome.primeirojogo.telas. Em seguida, crie a classe TelaJogo.java com o seguinte conteúdo:

package com.seunome.primeirojogo.telas;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.seunome.primeirojogo.JogoMain;

public class TelaJogo implements Screen {

    private final JogoMain jogo;             // Referência ao jogo principal
    private OrthographicCamera camera;       // Câmera para visualizar o mundo do jogo
    private SpriteBatch batch;               // Usado para desenhar sprites
    private Texture texturaJogador;          // Textura do personagem principal
    private float posX, posY;                // Posições do jogador na tela

    public TelaJogo(JogoMain jogo) {
        this.jogo = jogo;
    }

    @Override
    public void show() {
        // Configura câmera com largura e altura virtuais
        camera = new OrthographicCamera();
        camera.setToOrtho(false, 800, 480);

        batch = new SpriteBatch();

        // Carrega textura (adicione a imagem em core/assets)
        texturaJogador = new Texture(Gdx.files.internal("imagens/jogador.png"));

        // Posição inicial do jogador
        posX = 400 - texturaJogador.getWidth() / 2f;
        posY = 240 - texturaJogador.getHeight() / 2f;
    }

    @Override
    public void render(float delta) {
        // Limpa tela com cor preta
        Gdx.gl.glClearColor(0, 0, 0, 1); 
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

        // Atualiza câmera
        camera.update();
        batch.setProjectionMatrix(camera.combined);

        // Desenha jogador
        batch.begin();
        batch.draw(texturaJogador, posX, posY);
        batch.end();

        // Lógica simples: movimentar o jogador para a direita continuamente
        posX += 200 * delta; // 200 pixels por segundo

        // Se o jogador sair da tela, retornar ao início
        if (posX > 800) {
            posX = -texturaJogador.getWidth();
        }
    }

    @Override
    public void resize(int width, int height) {
        // Tratamento se o tamanho da janela mudar (opcional para protótipos)
    }

    @Override
    public void pause() {
        // Chamado quando o jogo for pausado (por exemplo, trocar de aba no Android)
    }

    @Override
    public void resume() {
        // Chamado quando o jogo voltar de pausa
    }

    @Override
    public void hide() {
        // Chamado quando a tela não estiver mais visível
    }

    @Override
    public void dispose() {
        // Libera recursos
        batch.dispose();
        texturaJogador.dispose();
    }
}

Nesse código, temos alguns pontos importantes:

• OrthographicCamera: Câmera ortográfica que define a área visível do jogo (nesse caso, 800×480 pixels).
• SpriteBatch: Classe responsável por agrupar e otimizar o desenho dos sprites.
• Texture: Imagem carregada para representar um objeto no jogo.
• delta: parâmetro que indica o tempo em segundos desde o último quadro. Isso garante que a movimentação do jogador seja suave, independente da taxa de quadros por segundo.

7. Adicionando Assets (Sprites, Ícones e Sons)

Para que o jogo funcione visualmente, precisamos colocar arquivos na pasta core/assets. Siga estas etapas:

1. Criar a pasta de imagens: Dentro de core/assets, crie a pasta imagens. Coloque nela um arquivo chamado jogador.png (por exemplo, um sprite de 64×64 pixels em formato PNG). Você pode desenhar seu próprio sprite no Krita ou baixar imagens gratuitas em OpenGameArt. Procure por “player sprite free”.
2. Adicionar ícones: Para deixar seu aplicativo com uma identidade, crie uma pasta icones dentro de core/assets e adicione ícones em diferentes resoluções (mdpi, hdpi, xhdpi etc.). O Android Studio gera automaticamente ícones se você usar o recurso “Image Asset” no módulo android. No entanto, para fins de protótipo, coloque um ícone simples em icones/ic_launcher.png.
3. Adicionar sons e música: Se desejar, crie uma pasta sons em core/assets e coloque efeitos sonoros (em WAV ou OGG). Exemplo: sons/salto.wav para o som de pulo. Você pode encontrar sons gratuitos em Freesound.

Após adicionar os arquivos, o libGDX os reconhecerá automaticamente, pois a pasta assets do módulo core é incluída no build.gradle e empacotada no APK Android.

8. Executando o Jogo no Módulo Desktop para Testes Rápidos

Antes de rodar no emulador Android, é recomendável testar a versão Desktop. Assim, o feedback é mais rápido e você não precisa aguardar longas compilações.

No módulo desktop, abra a classe principal (por exemplo, DesktopLauncher.java), que geralmente está em desktop/src/com/seunome/primeirojogo/deskop:

package com.seunome.primeirojogo.desktop;

import com.badlogic.gdx.backends.lwjgl.LwjglApplication;
import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;
import com.seunome.primeirojogo.JogoMain;

public class DesktopLauncher {
    public static void main (String[] arg) {
        LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();
        config.title = "Primeiro Jogo Android";
        config.width = 800;
        config.height = 480;
        new LwjglApplication(new JogoMain(), config);
    }
}

Para executar:

• Clique com o botão direito em DesktopLauncher.java e selecione “Run ‘DesktopLauncher.main()’”.
• Aguarde alguns segundos até aparecer uma janela com o seu jogo simples, onde um sprite se movimenta da esquerda para a direita.

Se tudo estiver correto, parabéns! Seu ambiente está configurado e o jogo está rodando no Desktop. Agora é hora de levar aos dispositivos Android.

9. Configurando o Emulador Android (AVD) ou Dispositivo Físico

Para testar no Android, você pode usar um emulador (Android Virtual Device – AVD) ou conectar um dispositivo físico via USB:

9.1. Criando um Emulador (AVD)

1. No Android Studio, acesse Tools > AVD Manager.
2. Clique em Create Virtual Device.
3. Selecione um dispositivo, por exemplo, Pixel 3a e clique em “Next”.
4. Escolha uma imagem de sistema (recomendamos Android 12.0 (Google Play)) e faça o download se ainda não tiver.
5. Clique em “Finish” para criar o AVD.
6. Para abrir o emulador, clique no ícone de “play” ao lado do nome do AVD ou inicie pelo AVD Manager.

9.2. Conectando Dispositivo Físico

1. No Android Studio, vá em File > Settings > Appearance > System Settings > Android SDK e confira se o “Google USB Driver” está instalado (Windows) ou se você configurou os drivers ADB para Linux/Mac.
2. No seu smartphone Android, ative a Opção de Desenvolvedor (vá em Configurações > Sobre o telefone > toque sete vezes em “Número da versão”).
3. Ative Depuração USB nas opções de desenvolvedor.
4. Conecte o dispositivo via cabo USB ao computador e aceite a mensagem de permissão de depuração no smartphone.
5. No Android Studio, verifique se o dispositivo aparece na lista de dispositivos disponíveis no canto superior direito da janela.

Com o emulador rodando ou o dispositivo conectado, vamos configurar o módulo android para compilar e instalar o APK.

10. Configurando e Executando o Projeto no Android

1. Selecione o módulo android: Na barra superior do Android Studio, há um menu suspenso que indica o módulo de execução. Por padrão, aparece algo como “app” ou “android”. Selecione o módulo android gerado pelo libGDX.
2. Escolha o dispositivo: Ao lado do módulo, selecione o emulador ou dispositivo conectado.
3. Clique em “Run” (ícone de play verde): O Android Studio iniciará a compilação e instalação do APK no dispositivo/emulador. Esse processo pode levar alguns segundos.
4. Confira no dispositivo: Assim que instalado, o ícone do jogo aparecerá no lançador de aplicativos. Toque para abrir e veja seu primeiro jogo em ação no smartphone!

Se tudo estiver funcionando corretamente, você verá a mesma animação do sprite se movendo da esquerda para a direita na tela do smartphone ou emulador. Parabéns, você criou e executou seu primeiro jogo Android!

11. Adicionando Controles e Interação

Agora que temos um sprite simples se movimentando, é hora de incluir controles para interagir com o jogador. Vamos criar um controle por toque para que o jogador possa mover o personagem horizontalmente conforme a posição do toque na tela.

Altere o método render da classe TelaJogo para observar eventos de toque:

@Override
public void render(float delta) {
    Gdx.gl.glClearColor(0, 0, 0, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    camera.update();
    batch.setProjectionMatrix(camera.combined);

    // Verifica se houve toque na tela
    if (Gdx.input.isTouched()) {
        // Obtém posição do toque (em coordenadas de tela)
        float toqueX = Gdx.input.getX();
        float toqueY = Gdx.input.getY();

        // Converte coordenadas de tela para coordenadas da câmera
        Vector3 posicaoToque = new Vector3(toqueX, toqueY, 0);
        camera.unproject(posicaoToque);

        // Move jogador para a posição X do toque
        posX = posicaoToque.x - texturaJogador.getWidth() / 2f;
        posY = posicaoToque.y - texturaJogador.getHeight() / 2f;
    } else {
        // Se não houver toque, o jogador continua se movendo para a direita automaticamente
        posX += 200 * delta;
        if (posX > 800) {
            posX = -texturaJogador.getWidth();
        }
    }

    batch.begin();
    batch.draw(texturaJogador, posX, posY);
    batch.end();
}

Agora, ao tocar na tela, o sprite “se teleportará” para a posição do toque. Se nenhum toque for detectado, ele continuará seu movimento automático. Isso traz uma sensação de controle mais direta para o jogador.

12. Implementando Animação de Sprite

Para deixar o jogo mais dinâmico, nada melhor do que animar o personagem. Em vez de uma imagem estática, usaremos um spritesheet (folha de sprites) para animar o personagem andando.

12.1. Preparando o Spritesheet

Um spritesheet é uma imagem que contém várias “frames” (quadros) de animação organizados em linhas e colunas. Por exemplo, um arquivo jogador_spritesheet.png com 4 colunas e 2 linhas, totalizando 8 frames.

• Dimensões do spritesheet: 256×128 pixels, onde cada frame tem 64×64 pixels.
• Frames organizados horizontalmente (para a animação de andar).

Coloque o arquivo jogador_spritesheet.png em core/assets/imagens.

12.2. Carregando o Spritesheet no Código

Abra TelaJogo.java e declare variáveis para armazenar o Texture, o Animation<TextureRegion> e o elapsedTime:

import com.badlogic.gdx.graphics.g2d.Animation;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
// outras importações...

public class TelaJogo implements Screen {
    // ... variáveis existentes
    private Animation animacaoAndar;
    private float tempoAnimacao;
    // ...
}

No método show(), carregue o spritesheet e crie a animação:

@Override
public void show() {
    // Configurando câmera e batch (igual antes)
    camera = new OrthographicCamera();
    camera.setToOrtho(false, 800, 480);
    batch = new SpriteBatch();

    // Carregando spritesheet
    Texture spritesheet = new Texture(Gdx.files.internal("imagens/jogador_spritesheet.png"));

    // Dividindo o spritesheet em regiões de 64x64 pixels
    TextureRegion[][] quadros = TextureRegion.split(spritesheet, 64, 64);

    // Criando um array com as regiões de animação (assumindo 4 colunas e 2 linhas)
    TextureRegion[] frames = new TextureRegion[8];
    int index = 0;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 4; j++) {
            frames[index++] = quadros[i][j];
        }
    }

    // Criando a animação: cada frame dura 0.1 segundos
    animacaoAndar = new Animation(0.1f, frames);
    animacaoAndar.setPlayMode(Animation.PlayMode.LOOP);

    // Tempo inicial
    tempoAnimacao = 0f;

    // Posição inicial do jogador
    posX = 400 - 32; // 32 = largura do frame / 2
    posY = 240 - 32;
}

12.3. Atualizando o Desenho no Método render()

No início do método render(), incremente o elapsedTime e obtenha o frame atual:

@Override
public void render(float delta) {
    tempoAnimacao += delta; // incrementa o tempo de animação

    // Limpar tela
    Gdx.gl.glClearColor(0, 0, 0, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    camera.update();
    batch.setProjectionMatrix(camera.combined);

    // Verificar toque e movimentar jogador (igual antes)...
    // (este bloco permanece inalterado)

    // Obter frame atual da animação
    TextureRegion frameAtual = animacaoAndar.getKeyFrame(tempoAnimacao);

    // Desenhar o frame atual
    batch.begin();
    batch.draw(frameAtual, posX, posY);
    batch.end();
}

Pronto! Agora seu personagem está se movendo e animado. Isso traz uma sensação de vida ao jogo e envolve muito mais o jogador.

13. Implementando Colisão com Obstáculos

Vamos adicionar um obstáculo simples (por exemplo, uma pedra) para que o jogador precise desviar. Crie uma nova imagem chamada obstaculo.png (por exemplo, 64×64 pixels) e coloque em core/assets/imagens.

13.1. Carregando o Obstáculo

No início da classe TelaJogo, declare variáveis para o obstáculo:

private Texture texturaObstaculo;
private float obsX, obsY;

No método show(), carregue a textura e defina a posição do obstáculo:

@Override
public void show() {
    // Código anterior (spritesheet, câmera, batch)...

    // Carregar textura do obstáculo
    texturaObstaculo = new Texture(Gdx.files.internal("imagens/obstaculo.png"));

    // Posição inicial do obstáculo (no meio da tela, por exemplo)
    obsX = 400 - texturaObstaculo.getWidth() / 2f;
    obsY = 100;
}

13.2. Desenhando e Atualizando o Obstáculo

No método render(), antes de desenhar o jogador, desenhe o obstáculo:

@Override
public void render(float delta) {
    tempoAnimacao += delta;
    Gdx.gl.glClearColor(0, 0, 0, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    camera.update();
    batch.setProjectionMatrix(camera.combined);

    // Lógica de toque e movimentação do jogador (igual antes)...

    // Atualizar evento de colisão
    Rectangle rectJogador = new Rectangle(posX, posY, 64, 64);
    Rectangle rectObstaculo = new Rectangle(obsX, obsY, texturaObstaculo.getWidth(), texturaObstaculo.getHeight());

    if (rectJogador.overlaps(rectObstaculo)) {
        // Colisão detectada: resetar posição do jogador
        posX = 400 - 32;
        posY = 240 - 32;
        tempoAnimacao = 0f; // reiniciar animação
    }

    // Desenhar obstáculo
    batch.begin();
    batch.draw(texturaObstaculo, obsX, obsY);

    // Desenhar jogador animado
    TextureRegion frameAtual = animacaoAndar.getKeyFrame(tempoAnimacao);
    batch.draw(frameAtual, posX, posY);
    batch.end();
}

Note que usamos Rectangle (do pacote com.badlogic.gdx.math) para detectar colisões por meio do método overlaps. Quando o jogador colidir com o obstáculo, sua posição é resetada ao centro da tela.

14. Adicionando Interface Gráfica (HUD)

Para tornar o jogo mais interessante, vamos criar um contador de pontuação (score) que aumenta à medida que o jogador desvia do obstáculo. Toda vez que o obstáculo passar pela borda esquerda da tela e retornar, somamos 1 ponto.

14.1. Declarando Variáveis de Pontuação

No início da classe TelaJogo, adicione:

private BitmapFont fonte; // Fonte para desenhar texto
private int pontuacao;

14.2. Inicializando a Fonte e a Pontuação

No método show(), após carregar o obstáculo, crie a fonte e inicialize a pontuação:

@Override
public void show() {
    // (código anterior: câmera, batch, spritesheet, obstáculo...)

    // Criar BitmapFont padrão
    fonte = new BitmapFont(); 
    fonte.getData().setScale(2); // aumentar o tamanho da fonte

    // Pontuação inicial
    pontuacao = 0;
}

14.3. Lógica de Atualização da Pontuação

No método render(), antes de verificar colisão, atualize a posição do obstáculo e pontuação:

@Override
public void render(float delta) {
    tempoAnimacao += delta;
    Gdx.gl.glClearColor(0, 0, 0, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

    camera.update();
    batch.setProjectionMatrix(camera.combined);

    // Lógica de toque e movimentação do jogador (igual antes)...

    // Movimentar obstáculo para a esquerda
    obsX -= 150 * delta; // obstáculo se move a 150 pixels por segundo

    // Se o obstáculo sair da tela à esquerda, reposicione-o à direita e aumente pontuação
    if (obsX + texturaObstaculo.getWidth() < 0) {
        obsX = 800; // volta para a direita da tela
        pontuacao += 1;
    }

    // Detectar colisão (igual antes)...

    // Desenhar tudo
    batch.begin();
    batch.draw(texturaObstaculo, obsX, obsY);
    TextureRegion frameAtual = animacaoAndar.getKeyFrame(tempoAnimacao);
    batch.draw(frameAtual, posX, posY);

    // Desenhar pontuação no canto superior esquerdo
    fonte.draw(batch, "Pontuação: " + pontuacao, 20, 460);
    batch.end();
}

Assim, toda vez que o obstáculo “escapa” pela esquerda, reposicionamos na direita (valor de x=800) e incrementamos a pontuação. A HUD mostra a pontuação atual em tempo real.

15. Melhorando a Experiência do Jogador

Para que seu jogo fique mais atraente, considere implementar:

• Sons e Efeitos Sonoros: ao pular, colidir ou ganhar pontos. Exemplo: Gdx.audio.newSound(Gdx.files.internal("sons/pulo.ogg")).
• Tela de Menu Inicial: com opções como “Jogar”, “Instruções” e “Sair”. Para isso, crie outra classe que estenda Screen (por exemplo, TelaMenu.java) e defina botões.
• Tela de Game Over: exiba a pontuação final e opções para reiniciar ou voltar ao menu.
• Animação de Fundo: adicione um cenário em core/assets/imagens, como nuvens ou montanhas que se movem lentamente para dar profundidade.
• Animação de Pausa: pausar o jogo ao tocar em um botão de pausa e exibir um overlay sem interromper o loop de renderização (use boolean pausado para controlar).

16. Adicionando Tela Inicial (TelaMenu)

Vamos criar uma tela simples de menu com dois botões (Jogar e Sair). Crie a classe TelaMenu.java em com.seunome.primeirojogo.telas:

package com.seunome.primeirojogo.telas;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.Rectangle;
import com.seunome.primeirojogo.JogoMain;

public class TelaMenu implements Screen {

    private JogoMain jogo;
    private SpriteBatch batch;
    private Texture texturaPlanoDeFundo;
    private BitmapFont fonteTitulo, fonteBotao;
    private Rectangle botoesJogar, botoesSair;

    public TelaMenu(JogoMain jogo) {
        this.jogo = jogo;
    }

    @Override
    public void show() {
        batch = new SpriteBatch();
        texturaPlanoDeFundo = new Texture(Gdx.files.internal("imagens/menu_fundo.png"));

        fonteTitulo = new BitmapFont();
        fonteTitulo.getData().setScale(3);

        fonteBotao = new BitmapFont();
        fonteBotao.getData().setScale(2);

        // Definir áreas dos botões (coordenadas e tamanho)
        botoesJogar = new Rectangle(300, 300, 200, 50);
        botoesSair = new Rectangle(300, 200, 200, 50);
    }

    @Override
    public void render(float delta) {
        Gdx.gl.glClearColor(0, 0, 0, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

        batch.begin();
        batch.draw(texturaPlanoDeFundo, 0, 0, 800, 480);

        fonteTitulo.draw(batch, "Meu Primeiro Jogo!", 250, 430);

        fonteBotao.draw(batch, "JOGAR", botoesJogar.x + 50, botoesJogar.y + 35);
        fonteBotao.draw(batch, "SAIR", botoesSair.x + 65, botoesSair.y + 35);

        batch.end();

        // Verificar clique nos botões
        if (Gdx.input.justTouched()) {
            float toqueX = Gdx.input.getX();
            float toqueY = Gdx.input.getY();
            // Converter coordenadas
            Vector3 toques = new Vector3(toqueX, toqueY, 0);
            jogo.getCamera().unproject(toques);

            if (botoesJogar.contains(toques.x, toques.y)) {
                jogo.setScreen(new TelaJogo(jogo)); // Vai para a tela de jogo
            } else if (botoesSair.contains(toques.x, toques.y)) {
                Gdx.app.exit(); // Fecha o aplicativo
            }
        }
    }

    @Override
    public void resize(int width, int height) {
    }

    @Override
    public void pause() {
    }

    @Override
    public void resume() {
    }

    @Override
    public void hide() {
    }

    @Override
    public void dispose() {
        batch.dispose();
        texturaPlanoDeFundo.dispose();
        fonteTitulo.dispose();
        fonteBotao.dispose();
    }
}

Para que esse menu funcione, ajuste o método create() em JogoMain.java:

@Override
public void create() {
    setScreen(new TelaMenu(this)); // Mostrar menu ao iniciar
}

public OrthographicCamera getCamera() {
    // Facilita compartilhamento da câmera com outras telas
    return new OrthographicCamera(800, 480);
}

Além disso, adicione a imagem de fundo (menu_fundo.png) em core/assets/imagens. Essa imagem pode ser algo simples, como um padrão colorido ou um cenário que combine com o tema do seu jogo.

17. Construindo a Tela de Game Over

Quando o jogador colidir com o obstáculo mais de um número definido de vezes ou quando desejar finalizar a partida, exiba uma tela de Game Over com a pontuação final e botão para voltar ao menu.

package com.seunome.primeirojogo.telas;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.Rectangle;
import com.seunome.primeirojogo.JogoMain;

public class TelaGameOver implements Screen {

    private JogoMain jogo;
    private SpriteBatch batch;
    private BitmapFont fonteTitulo, fonteInfo;
    private Texture texturaFundo;
    private Rectangle botaoMenu;
    private int pontuacaoFinal;

    public TelaGameOver(JogoMain jogo, int pontuacaoFinal) {
        this.jogo = jogo;
        this.pontuacaoFinal = pontuacaoFinal;
    }

    @Override
    public void show() {
        batch = new SpriteBatch();
        texturaFundo = new Texture(Gdx.files.internal("imagens/gameover_fundo.png"));

        fonteTitulo = new BitmapFont();
        fonteTitulo.getData().setScale(4);

        fonteInfo = new BitmapFont();
        fonteInfo.getData().setScale(2);

        botaoMenu = new Rectangle(300, 100, 200, 50);
    }

    @Override
    public void render(float delta) {
        Gdx.gl.glClearColor(0, 0, 0, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

        batch.begin();
        batch.draw(texturaFundo, 0, 0, 800, 480);

        fonteTitulo.draw(batch, "Game Over", 280, 350);
        fonteInfo.draw(batch, "Pontuação: " + pontuacaoFinal, 320, 280);
        fonteInfo.draw(batch, "Voltar ao Menu", botaoMenu.x + 20, botaoMenu.y + 35);
        batch.end();

        if (Gdx.input.justTouched()) {
            float toqueX = Gdx.input.getX();
            float toqueY = Gdx.input.getY();
            Vector3 toques = new Vector3(toqueX, toqueY, 0);
            jogo.getCamera().unproject(toques);

            if (botaoMenu.contains(toques.x, toques.y)) {
                jogo.setScreen(new TelaMenu(jogo));
            }
        }
    }

    @Override
    public void resize(int width, int height) {
    }

    @Override
    public void pause() {
    }

    @Override
    public void resume() {
    }

    @Override
    public void hide() {
    }

    @Override
    public void dispose() {
        batch.dispose();
        texturaFundo.dispose();
        fonteTitulo.dispose();
        fonteInfo.dispose();
    }
}

No código acima, a tela de Game Over exibe um fundo (imagem gameover_fundo.png em core/assets/imagens), o texto “Game Over” e a pontuação final. Ao tocar no botão “Voltar ao Menu”, o jogo retorna para a tela inicial.

18. Aperfeiçoando a Qualidade Visual

Um bom visual faz diferença para engajar jogadores. Veja algumas dicas para incrementar os gráficos do seu jogo:

• Sons Ambientais: adicione um arquivo de música de fundo em loop (por exemplo, sons/musica_fundo.ogg).
• Camadas de Fundo (Parallax): use várias imagens de cenário que se movem em velocidades diferentes para dar profundidade.
• Partículas: implemente efeitos de partículas para explosões, poeira ou chuva usando ParticleEffect do libGDX.
• Interface Customizada: use Skin e Scene2D UI (libGDX) para criar botões e janelas com estilo próprio.
• Paleta de Cores Coesa: escolha cores que combinem entre si e transmitam a atmosfera desejada (por exemplo, tons escuros para jogos tensos, tons vibrantes para jogos casuais).

19. Adicionando Persistência de Dados (Salvar Pontuação)

Para que a pontuação seja salva mesmo após fechar o jogo, utilize o recurso de Preferences do libGDX. Ele funciona como um SharedPreferences no Android, permitindo armazenar dados simples no aparelho.

19.1. Salvando a Maior Pontuação

No início da classe TelaJogo, declare:

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Preferences;

// ...

private Preferences preferencias;
private int recorde;

No método show(), inicialize as preferências e carregue o recorde:

@Override
public void show() {
    // Código anterior (câmera, batch, spritesheet, obstáculo, fonte...)

    // Inicializar Preferences
    preferencias = Gdx.app.getPreferences("MeuJogoPreff");

    // Carregar recorde, caso exista (default = 0)
    recorde = preferencias.getInteger("recorde", 0);
}

19.2. Atualizando e Salvando o Recorde

No bloco onde incrementamos a pontuação, adicione verificação de recorde:

// Se o obstáculo sair da tela à esquerda, reposicione-o à direita e atualize pontuação
if (obsX + texturaObstaculo.getWidth() < 0) {
    obsX = 800;
    pontuacao += 1;

    // Verificar se nova pontuação é maior que recorde
    if (pontuacao > recorde) {
        recorde = pontuacao;
        // Salvar novo recorde nas preferências
        preferencias.putInteger("recorde", recorde);
        preferencias.flush(); // Garante escrita imediata
    }
}

Na HUD, exiba também o recorde atual abaixo da pontuação:

fonte.draw(batch, "Recorde: " + recorde, 20, 430);

20. Finalizando e Gerando o APK

Depois de implementar todas as funcionalidades desejadas (menu, jogo, colisão, pontuação, game over, som e animações), é hora de gerar o APK para compartilhar com amigos:

1. Configurar assinatura de release: No Android Studio, vá em Build > Generate Signed Bundle / APK.
2. Escolher “APK” e clicar em “Next”.
3. Criar um novo keystore (se ainda não tiver):
   • Selecione “Create new” e preencha senha, alias, data de validade e informações pessoais mínimas.
   • Escolha onde salvar o keystore (ex: primeirojogo.jks). Guarde essa senha em local seguro.
4. Preencher campos de assinatura:
   • Keystore path: caminho para o arquivo .jks
   • Keystore password: senha que você definiu
   • Key alias: alias definido
   • Key password: senha do alias (pode ser igual à do keystore)
5. Escolher variantes: Selecione “release” no menu suspenso de Build Variants.
6. Clicar em “Finish”: O Android Studio vai gerar o APK assinado na pasta android/app/release, chamado app-release.apk.
7. Testar o APK: Transfira para seu celular ou emulador e instale para conferir se tudo funciona como esperado.

Pronto! Agora você tem um APK de release pronto para compartilhar com amigos, publicar em grupos de teste ou até mesmo enviar para a Google Play Store. Se quiser publicar na Play Store, será necessário criar uma conta de desenvolvedor (custa aproximadamente US$ 25) em Google Play Console e seguir as instruções de publicação (descrição, screenshots, política de privacidade e envio do APK).

21. Testando e Recebendo Feedback

Para melhorar seu jogo, peça para amigos e familiares testarem e darem opiniões sobre:

• Jogabilidade e controles: estão responsivos? É fácil entender a dinâmica?
• Nível de dificuldade: é muito fácil ou muito difícil? Ajuste a velocidade do obstáculo ou frequência de aparição.
• Grafismo e sons: as animações fluem bem? Os sons são agradáveis e não irritam?
• Desempenho: funciona em aparelhos mais simples? Evite usar texturas muito grandes que possam travar em dispositivos com pouca memória.
• Erros e bugs: registre comportamentos inesperados para corrigir antes do lançamento oficial.

Anote todo feedback e implemente melhorias em ciclos de teste curtos, corrigindo bugs e refinando a experiência do jogador. A comunidade do libGDX (GitHub e StackOverflow) é muito ativa e pode ajudar quando surgir alguma dúvida.

22. Publicando seu Jogo na Google Play Store

Publicar o jogo na Play Store é o próximo passo para alcançar um público maior. Veja um resumo do processo:

1. Criar conta de desenvolvedor: Acesse Google Play Console e pague a taxa única de registro (US$ 25).
2. Configurar ficha do aplicativo:
   • Nome do aplicativo em diferentes idiomas.
   • Descrição resumida e detalhada.
   • Ícones, screenshots (720x1280 pixels) e vídeos de apresentação.
   • Categoria (jogos, ação, casual, etc.) e classificação etária.
   • Política de privacidade (se seu jogo coletar dados do usuário).
3. Fazer upload do APK assinado: No menu “Release Management > App Releases”, crie um novo release, faça upload do app-release.apk e envie para a revisão.
4. Aguardar análise: A equipe do Google revisará seu aplicativo e, se tudo estiver em conformidade com as políticas, seu jogo será publicado em algumas horas ou dias.
5. Promover seu jogo: compartilhe em redes sociais, grupos de desenvolvedores e fóruns para obter downloads e avaliações iniciais.

23. Dicas Finais para Continuar Evoluindo como Desenvolvedor de Jogos

Parabéns por ter chegado até aqui! Agora você tem uma base sólida para criar jogos Android simples e dinâmicos. Para continuar crescendo na área, confira as seguintes recomendações:

• Estude Game Design: compreenda o que faz um jogo ser viciante, com mecânicas equilibradas e desafio adequado. Livros como “A Arte do Game Design: o Livro dos Requisitos” de Jesse Schell são excelentes.
• Pratique com tutoriais avançados: explore recursos de física (Box2D), IA básica para inimigos, pathfinding e redes para jogos multiplayer locais ou online.
• Participe de Game Jams: eventos como itch.io/jams reúnem desenvolvedores em maratonas de criação. Ótimo para expandir portfólio e aprender sob pressão.
• Estude frameworks alternativos: Unity (unity.com) e Godot (godotengine.org) são outras opções muito utilizadas no mercado. Experimentar novas ferramentas amplia seu leque de oportunidades.
• Construa um portfólio online: crie um site ou portfólio no GitHub ou itch.io com seus projetos. Isso ajuda recrutadores e estúdios a conhecerem seu trabalho.
• Networking: conecte-se com outros desenvolvedores no LinkedIn, fóruns do Reddit (r/gamedev) e grupos do Discord focados em desenvolvimento de jogos.
• Fique por dentro das tendências: acompanhe blogs como GameDev.net, Gamasutra (agora Game Developer) e canais do YouTube que apresentam discussões sobre mercado, monetização e técnicas avançadas.
• Aprenda Matemática e Física básica: conhecimentos em trigonometria, vetores e álgebra linear podem ser fundamentais conforme seus jogos aumentarem de complexidade.

24. Conclusão

Desenvolver seu primeiro jogo no Android Studio com libGDX é uma jornada desafiadora, mas extremamente recompensadora. Você aprendeu desde a criação do projeto, configuração de emulador, renderização de sprites e animações, até a implementação de lógica de colisão, pontuação, telas de menu e game over. Além disso, viu como adicionar assets, manipular inputs de toque e gerar APKs assinados para publicação.

Esse projeto serve como ponto de partida para criar jogos cada vez mais complexos e sofisticados. Lembre-se que a prática constante, a busca por recursos de aprendizado e a participação em comunidades de desenvolvedores são fundamentais para aprimorar suas habilidades. Não tenha medo de experimentar novas ideias, quebrar o código e reinventar seu jogo quantas vezes forem necessárias até encontrar a experiência ideal.

O mundo dos jogos está em constante evolução, com novas ferramentas, tecnologias e tendências surgindo a cada dia. Aproveite as dicas finais para continuar evoluindo e, em breve, você poderá criar jogos 2D, 3D, multiplayer e até realidade aumentada. O importante é manter a paixão e a curiosidade sempre acesas.

Agora é com você: abra o Android Studio, coloque a mão no código e comece a transformar suas ideias em realidade! E não se esqueça, compartilhe seu progresso e dúvidas na comunidade do JovemProjeto.com.br para inspirar outros jovens desenvolvedores como você.

Que a criatividade guie seus pixels. Bom desenvolvimento!