Criar Jogos 2D em Unity: Criando Games do Zero

Antes dos gráficos realistas e avançados, antes do ray tracing e iluminação realista e imersiva dos games atuais, como um Frontiers of Pandora, Assassin’s Creed Mirage e outros, nós jogávamos com sprites laterais que se moviam sempre em duas direções.

Claro, ainda hoje os jogos 2D existem e fazem grande sucesso, como o Lenda do Herói e Sonic Mania, mas é uma escolha dos programadores fazerem esses games com esse estilo relembrar uma época em que os jogos eram mais simples.

O Unity 3D (site oficial) é uma ferramenta poderosa que pode ser usada para criar jogos de todos os tipos, incluindo Jogos 2D em Unity.

Desenvolver jogos é uma jornada fascinante e cheia de possibilidades. Começando do zero, desde a configuração inicial até a implementação do jogador no jogo, vamos explorar passo a passo como você pode criar seu próprio jogo 2D neste ambiente versátil.

Neste artigo, vamos mostrar como criar jogos 2D do zero na Unity, desde a criação do projeto até a entrega e, se você ficar com dúvidas, é só deixar um comentário.

Você também pode gostar:
Programador De Gameplay
Prop Artist: Trabalhando Com Arte
Visual Studio Code: Substituto do Clássico
Quer Criar Jogos? Veja este Guia
Desenvolvimento De Plugins Passo-a-Passo

Fazer Carreira Desenvolvendo Jogos em Unity é Fácil

Configurando o Projeto 2D na Unity

Iniciar um novo projeto no Unity é o primeiro passo. Ao selecionar “Novo Projeto”, escolha a opção “2D” para definir o ambiente para jogos 2D. Isso estabelece automaticamente as configurações ideais para começar a trabalhar nesse tipo de projeto, como ajustes de câmera e física.

Para criar um projeto 2D na Unity, siga estas etapas:

1. Inicie o Unity.
2. No menu File, selecione New.
3. No menu Project Template, selecione 2D.
4. No campo Project Name, insira um nome para seu projeto.
5. Clique em Create.

A Unity criará um novo projeto 2D com um cenário vazio e um jogador 2D básico.

Selecionando o Template Adequado

Entre as opções de templates fornecidas pelo Unity, escolha o template “2D”. Esse template é otimizado para jogos 2D, oferecendo ajustes específicos e facilitando a construção de jogos desse estilo. A Unity oferece dois templates 2D: 2D e 2D Side Scroller.

O template 2D é o mais básico e inclui um cenário vazio e um jogador 2D. O template 2D Side Scroller é mais avançado e inclui um cenário de plataforma side-scroller e um jogador com movimento limitado. Para jogos 2D simples, o template 2D é suficiente. Para jogos 2D mais complexos, você pode usar o template 2D Side Scroller ou criar seu próprio template personalizado.

Forma correta de nomear seu projeto

É importante nomear seu projeto de forma clara e concisa. O nome do seu projeto deve ser fácil de lembrar e deve fornecer informações sobre o conteúdo do projeto. Por exemplo, um jogo de plataforma 2D chamado “My Platformer Game” é um bom nome. Um jogo de aventura 2D chamado “The Adventure of the Lost Treasure” também é um bom nome.

A nomenclatura do seu projeto é crucial. Opte por um nome descritivo que represente o conceito ou a ideia central do jogo. Isso facilita a identificação e organização do projeto durante o desenvolvimento e também garante uma boa forma de se controlar o versionamento do seu projeto. Além de usar um controlador de versão, como o GitKraken, dar um nome simples e intuitivo como “meuprojeto v1”, “meuprojeto v2”, e etc ajudará você a saber em qual ponto do projeto está.

Implementando o Player 2D

Criar o personagem controlável (player) é um passo essencial. Comece adicionando um objeto do tipo Sprite, o qual será a representação visual do jogador. Configure a imagem ou animação para representar o player no jogo. Para controlar o movimento e interação do jogador no mundo do jogo, adicione um componente de física, como Rigidbody2D. Isso permite que o personagem responda à gravidade, colisões e interações com o ambiente.

A implementação dos controles de movimento, interações e outras mecânicas é realizada por meio de scripts em C#. Esses scripts interpretam os inputs do jogador e traduzem esses comandos para movimentos e ações dentro do jogo. O player 2D é o personagem que o jogador controla no jogo. Para criar um player 2D na Unity, siga estas etapas:

1. No menu Hierarchy, selecione Create.
2. No menu GameObject, selecione 2D Object.
3. No menu 2D Object, selecione Sprite.

A Unity criará um novo objeto Sprite chamado Sprite.

Para mover o player 2D, você pode usar a propriedade Position do objeto. A propriedade Position define a posição do objeto no mundo.

Para alterar a aparência do player 2D, você pode alterar a propriedade Sprite do objeto. A propriedade Sprite define o sprite que é usado para representar o objeto.

Criando o primeiro jogo 2D em Unity: passo a passo

Agora que você já configurou seu ambiente de desenvolvimento em Unity, é hora de começar a criar seu primeiro jogo. Nesta seção, vamos percorrer os passos básicos para criar um jogo simples em Unity.

O primeiro passo é criar um novo projeto. Abra o Unity Hub e clique em “New”. Dê um nome ao seu projeto e escolha uma localização para salvá-lo. Em seguida, clique em “Create”.

Após criar o projeto, você será levado para a interface do Unity. Agora é hora de adicionar objetos e componentes ao seu jogo. Para adicionar um objeto à cena, clique com o botão direito do mouse na hierarquia e selecione “Create Empty”. Em seguida, arraste e solte um objeto da pasta “Prefabs” para a hierarquia.

Agora que você adicionou objetos à cena, é hora de configurar a cena. Você pode ajustar a posição, rotação e escala dos objetos selecionados no inspector. Além disso, você pode adicionar componentes aos objetos para adicionar funcionalidades, como movimento ou colisões.

Para adicionar interatividade ao seu jogo, você pode adicionar scripts aos objetos. Os scripts são escritos em C# e permitem que você controle o comportamento dos objetos. Para adicionar um script a um objeto, clique com o botão direito do mouse no objeto na hierarquia e selecione “Create Empty”. Em seguida, clique com o botão direito do mouse no objeto vazio e selecione “Create Script”. Dê um nome ao script e clique em “Create and Add”.

Agora que você adicionou interatividade ao seu jogo, é hora de testá-lo. Para testar o jogo, clique no botão “Play” no canto superior central da interface do Unity. Isso abrirá uma janela de reprodução onde você pode jogar o jogo e testar suas funcionalidades. Vamos fazer um jogo agora? Vamos lá!

Vamos começar a fazer um jogo

Vamos começar com um cenário simples e faremos ele no código. Esse cenário terá um fundo azul celeste simples de 1200 x 1200, um retângulo marrom, que será a terra, de 1200px de largura dividido no meio, como se fosse um buraco, e uns 100px de altura. E um circulo amarelo no centro como se fosse o sol. Se tudo der certo ele ficará mais ou menos assim:

Para criar o cenário descrito no Unity, você precisará criar um script que desenhe o fundo, o sol e a terra no cenário. No entanto, especificamente para desenhar formas geométricas básicas como círculos e retângulos e cores de fundo, o Unity geralmente depende de objetos e texturas prontos dentro do ambiente em vez de código para desenhar diretamente no espaço de jogo.

Aqui está um caminho genérico de como você pode fazer isso sem programação complexa:

1. Crie um Fundo Azul Celeste: Você pode criar um plano ou usar a UI Image se estiver trabalhando em uma cena 2D. Atribua uma cor azul celeste a ele via Material se for um objeto 3D ou simplesmente definindo a cor se for uma UI Image.
2. Crie a Terra:
   • Para o chão, você pode usar um objeto como um Quad para 3D ou um Sprite para 2D, dependendo da sua necessidade.
   • Para representar a divisão “como se fosse um buraco”, pode-se ou alterar a textura do Quad/Sprite para ter uma aparência dividida ou usar dois objetos separados posicionados lado a lado.
3. Crie o Sol:
   • Use outro objeto Sprite para 2D ou uma esfera (Sphere) para 3D, ajuste para a cor amarelo e posicione onde desejar que o sol fique, por exemplo, no centro superior.

Aqui está um exemplo de como você pode configurar esse cenário na Unity para uma cena 2D:

1. Para o fundo, vá em GameObject -> UI -> Image, redimensione para cobrir a tela inteira, e mude a cor no Inspector.
2. Para a terra, vá em GameObject -> 2D Object -> Sprite. Escolha uma textura marrom ou simplesmente uma cor marrom. Para o “buraco”, você pode duplicar o sprite e ajustar o tamanho e/ou a textura.
3. Para o sol, repita o processo da terra, mas escolha uma cor amarela.

Colocando o personagem na tela

Com isso feito, agora vamos para o personagem. Assumindo que você já tem um sprite do seu personagem, a gente vai em frente. Se não, temos matérias sobre como desenhar personagens e sprites aqui no site. Vamos fazer com que ele se movimente pela tela e pule o buraco.

Certo. Agora, assumindo que eu já tenha um sprite de personagem, ele pode ser chamado de ‘Sprite’ para fins de identificá-lo no código. Eu preciso de um código que faça o sprite se mover usando as setas do teclado e pule ao apertar espaço.

Será um jogo 2D, então ele se movimenta apenas para direita e esquerda e pula na vertical para cima. Como você deve imaginar, ao pular, ele precisa seguir o movimento do pulo, usando a física da Unity, e o pulo deve ser suficiente para que ele ultrapasse o buraco. Como podemos fazer isso no Unity?

Para implementar o movimento do personagem e o pulo no Unity usando C#, você pode seguir os passos abaixo. Vamos criar um script chamado PlayerMovement. Este script lidará com o movimento horizontal baseado nas teclas de seta esquerda e direita, e com o pulo quando a tecla de espaço for pressionada.

1. Criando o Script:
   • No Unity, no painel “Project”, clique com o botão direito > Create > C# Script.
   • Nomeie o script como PlayerMovement.
   • Dê um duplo clique no script para abri-lo com o editor de código fonte que você estiver usando.
2. Escrevendo o Código: O script precisará de uma referência ao componente Rigidbody2D para aplicar física ao personagem. Também vamos definir variáveis para a velocidade de movimento, força do pulo e para verificar se o personagem está tocando o chão. Copie e cole o seguinte código dentro do script PlayerMovement.cs.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    public float movementSpeed = 5f;
    public float jumpForce = 10f;

    private Rigidbody2D myRigidbody;
    private bool isGrounded;

    void Start()
    {
        myRigidbody = GetComponent<Rigidbody2D>();
    }

    void Update()
    {
        Move();
        Jump();
    }

    void Move()
    {
        float movement = Input.GetAxis("Horizontal") * movementSpeed;
        transform.position += new Vector3(movement, 0, 0) * Time.deltaTime;
    }

    void Jump()
    {
        if (Input.GetButtonDown("Jump") && isGrounded)
        {
            myRigidbody.AddForce(new Vector2(0, jumpForce), ForceMode2D.Impulse);
            isGrounded = false; // Impede múltiplos pulos no ar
        }
    }

    // Detectando se o jogador está no chão
    void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.gameObject.tag == "Ground") // Certifique-se de que a plataforma/terra tenha a tag "Ground"
        {
            isGrounded = true;
        }
    }
}

3. Aplicando o Script ao Personagem:
   • Arraste e solte o script PlayerMovement para o objeto do personagem na cena.
   • Certifique-se de que o personagem tenha um componente Rigidbody2D anexado. Se não tiver, adicione um via “Add Component” no Inspetor.
   • Modifique o gravityScale do componente Rigidbody2D, se necessário, para alterar a ‘gravidade’ aplicada ao personagem.
   • Crie uma tag chamada “Ground” e aplique esta tag a todos os objetos que representarão o chão ou plataformas nas quais o personagem pode pular e se apoiar.

Esse código possibilitará que o personagem se mova para a esquerda e direita com as setas do teclado e pule ao pressionar a barra de espaço. A variável isGrounded é usada para garantir que o personagem só possa pular se estiver tocando o chão.

Sistema de Vidas

Agora, como um bom jogo 2D ele precisa de uma quantidade de vidas. Cada vez que o personagem falha em pular o buraco, ele perde uma vida. Como podemos fazer isso no Unity? Um sistema de tentativas antes do fim do jogo? Vamos dar ao nosso Sprite apenas três vidas.

Para implementar um sistema de vidas no seu jogo 2D no Unity, você pode seguir estes passos básicos:

1. Criar uma variável para contar as vidas: Você precisará de uma variável no seu script para armazenar a contagem atual de vidas. Esta variável será decrementada a cada vez que o jogador falhar.
2. Verificar colisões: Você deve ter um sistema para verificar quando o jogador falha, o que poderia ser um colisor no buraco que, ao entrar em contato com o jogador, decrementa uma vida.
3. Atualizar a IU (Interface do Usuário): Para informar o jogador quantas vidas ele ainda tem, é uma boa prática atualizar a interface do usuário a cada vez que a contagem de vidas muda.
4. Checar por Game Over: A cada vez que você decrementar uma vida, deve também verificar se a contagem chegou a zero, o que indicaria o fim do jogo. Neste ponto, você pode mostrar uma tela de “Game Over” e, possivelmente, oferecer ao jogador a opção de tentar novamente.

Aqui está um exemplo básico de como você pode implementar isso em um script C# para o Unity:

using UnityEngine;
using UnityEngine.UI; // Para trabalhar com UI

public class GameManager : MonoBehaviour
{
    public int lives = 3; // Inicializa com 3 vidas
    public Text livesText; // Referência para o texto de vidas na UI

    private void Start()
    {
        UpdateLivesText(); // Atualiza o texto de vidas no início
    }

    public void PlayerFailed()
    {
        lives--; // Decrementa uma vida
        UpdateLivesText();

        if (lives <= 0)
        {
            GameOver();
        }
    }

    void UpdateLivesText()
    {
        livesText.text = "Vidas: " + lives; // Atualiza o texto da UI
    }

    void GameOver()
    {
        // Código para gerenciar o fim do jogo
        Debug.Log("Game Over!");
    }
}

Para este script funcionar, você precisará:

• Ligar o Script ao Objeto: Adicione este script a um objeto em sua cena, que poderia ser um “GameManager”.
• Configurar a UI de Vidas: Crie um texto na UI para mostrar a contagem de vidas e, no Unity Editor, arraste este componente de texto para o campo livesText no seu script GameManager.
• Chamar PlayerFailed(): Certifique-se de chamar o método PlayerFailed() toda vez que o jogador falhar. Isso pode ser feito a partir do script de controle do jogador ou de um script anexado ao buraco que detecta a colisão com o jogador.

Este exemplo básico dá uma estrutura que você pode expandir e ajustar de acordo com as necessidades do seu jogo.

Pontuação

Para criar um sistema de score simples no Unity, basicamente, você precisa seguir alguns passos. Primeiro, você precisa armazenar a pontuação, atualizando-a quando eventos específicos acontecerem (como destruir um inimigo, coletar um item, etc.).

Depois, você vai querer exibir essa pontuação na tela para o jogador saber como está indo. Para isso, você pode usar a interface de usuário (UI) do Unity, especificamente um objeto Text para mostrar a pontuação. Vamos fazer um exemplo básico passo a passo:

1. Criar uma variável para armazenar a pontuação: Crie um script C# para gerenciar a pontuação. Neste script, você pode ter uma variável para armazenar a pontuação atual do jogador.
2. Atualizar a pontuação: No mesmo script ou em outros scripts que lidam com eventos no jogo (como destruir inimigos), você irá aumentar esta variável de pontuação baseada na ação completada pelo jogador.
3. Mostrar a pontuação na UI: Use o sistema UI do Unity para exibir a pontuação. Isso usualmente envolve criar um objeto Text na UI que é atualizado com a pontuação atual do jogador.

Vamos ver como isso poderia ser feito em código C#:

using UnityEngine;
using UnityEngine.UI; // Precisamos disso para trabalhar com elementos UI

public class ScoreManager : MonoBehaviour
{
    public static int score; // Pontuação do jogador. Estática para ser facilmente acessada de outros scripts
    public Text scoreText; // Referência ao componente Text onde queremos mostrar a pontuação

    void Start()
    {
        score = 0; // Inicialize a pontuação como 0
    }

    void Update()
    {
        // Atualiza o texto da UI para mostrar a pontuação atual
        scoreText.text = "Score: " + score;
    }

    public static void AddPoints(int points)
    {
        score += points; // Método para adicionar pontuação, pode ser chamado de outros scripts
    }
}

4. Adicionar pontos: Em qualquer script que lide com eventos que devem aumentar a pontuação (por exemplo, quando o jogador destroi um inimigo), você pode chamar ScoreManager.AddPoints(quantidadeDePontos); para atualizar a pontuação.
5. Crie um objeto Text na UI: No Unity, vá até a cena, adicione um elemento UI de Text, e então no painel de inspeção, arraste esse Text para o campo scoreText do seu ScoreManager componentizado em algum objeto (pode ser um GameObject vazio destinado a scripts gerenciadores).

Lembre-se de que este é um exemplo básico. Dependendo das necessidades específicas do seu jogo, você pode precisar adaptar e expandir este sistema, talvez criando um sistema mais complexo para lidar com pontuações altas, diferentes tipos de pontuação, etc.

Outros recursos para criar jogos 2D na Unity

Além dos recursos mencionados acima, a Unity oferece uma variedade de outros recursos que podem ser usados para criar jogos 2D. Esses recursos incluem:

• Ferramentas de modelagem e animação 2D: A Unity inclui ferramentas integradas para modelagem e animação 2D.
• Ferramentas de design de som: A Unity inclui ferramentas integradas para design de som.
• Ferramentas de controle de versão: A Unity inclui suporte integrado para controle de versão.
• Ferramentas de teste: A Unity inclui ferramentas integradas para teste de jogos.

Entrega dos Jogos 2D em Unity

Para entregar seu jogo, você pode usar um dos seguintes métodos:

• Publicar seu jogo na App Store ou Google Play: A Unity oferece suporte para publicação de jogos na App Store e Google Play.
• Publicar seu jogo em uma plataforma de distribuição independente: Existem várias plataformas de distribuição independente que permitem que você publique seu jogo sem a necessidade de um acordo de distribuição com uma editora.
• Enviar seu jogo para um evento de jogos: Eventos de jogos são uma ótima maneira de mostrar seu jogo para um público potencial.

Ao seguir esses passos iniciais, você estará no caminho certo para criar um jogo 2D completo no Unity. Aproveite a flexibilidade e os recursos disponíveis para dar vida à sua visão de jogo, seja ele uma aventura, um jogo de plataforma ou qualquer outra ideia criativa que você tenha.

O Unity é uma ferramenta poderosa que pode ser usada para criar jogos 2D de alta qualidade. Seguindo as etapas descritas neste artigo, e deixando o seu nome e contato nesse formulário abaixo, você pode começar a criar seus próprios jogos 2D hoje mesmo.

Explore tutoriais, documentações e a vasta comunidade online do Unity para aprofundar seus conhecimentos e expandir suas habilidades de desenvolvimento de jogos 2D.

Lembre-se, a prática consistente e a experimentação são fundamentais para aprimorar suas habilidades e criar experiências interativas cada vez mais envolventes. Divirta-se explorando o processo de desenvolvimento de jogos no Unity 3D!

FAQ Rápido

Fale conosco nos comentários e diga oque achou dessa matéria e aproveite para ler mais notícias e matérias, como por exemplo, sobre Motivos para usar a Unity, no nosso site.