Como fazer um jogo inspirado em Flappy Bird no Unity

Neste tutorial Unity, vamos percorrer o processo de criação de um jogo Flappy Bird. Este jogo clássico para celular envolve guiar um pássaro por uma série de canos tocando para fazê-lo bater as asas e evitar obstáculos. Vamos mergulhar nas instruções passo a passo.

Etapa 1: configure seu projeto Unity

• Se ainda não o fez, abra Unity e crie um novo projeto 2D.
• Defina as configurações do seu projeto, incluindo resolução e segmentação de plataforma.

Etapa 2: Importar ativos do jogo

• Encontre ou crie ativos para o pássaro, canos e fundo.
• Importe esses ativos para seu projeto Unity.

Etapa 3: Crie o Flappy Bird

• Adicione um sprite 2D para o pássaro.
• Implemente controles de toque simples para fazer o pássaro bater asas.
• Aplique a gravidade para fazer o pássaro cair naturalmente.

Etapa 4: Projete os tubos

• Crie um tubo prefab usando sprites 2D.
• Configure um sistema de spawn para gerar tubos em intervalos regulares.

Etapa 5: Implementar a lógica do jogo

• Adicione um sistema de pontuação para quem passar com sucesso pelos canos.
• Implemente a detecção de colisão para encerrar o jogo quando o pássaro atingir canos ou o chão.

Confira o script abaixo, ele encapsula as partes 3, 4 e 5.

'FlappyBird.cs'

using UnityEngine;
using System.Collections.Generic;

public class FlappyBird : MonoBehaviour
{
    public float jumpForce = 5f;
    public Transform pipeSpawnPoint;
    public GameObject pipePrefab;
    public float pipeSpawnInterval = 2f;
    public float pipeSpeed = 2f;

    private Rigidbody2D rb;
    private Transform mainCameraTransform;

    private List<GameObject> pipes = new List<GameObject>();

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        mainCameraTransform = Camera.main.transform;

        // Start spawning pipes
        InvokeRepeating("SpawnPipe", 2f, pipeSpawnInterval);
    }

    void Update()
    {
        // Flap when the screen is tapped or clicked
        if (Input.GetMouseButtonDown(0))
        {
            Flap();
        }

        // Move towards the pipes
        transform.Translate(Vector3.right * pipeSpeed * Time.deltaTime);

        // Move and manage spawned pipes
        foreach (GameObject pipe in pipes)
        {
            if (pipe != null)
            {
                pipe.transform.Translate(Vector3.left * pipeSpeed * Time.deltaTime);

                // End the game when colliding with pipes or ground
                if (pipe.CompareTag("Pipe") && IsCollidingWithPipe(pipe))
                {
                    EndGame();
                    return; // Exit the loop and update immediately
                }

                if (pipe.CompareTag("Ground") && IsCollidingWithGround(pipe))
                {
                    EndGame();
                    return; // Exit the loop and update immediately
                }

                // Remove pipes that are out of camera view
                if (pipe.transform.position.x < mainCameraTransform.position.x - 10f)
                {
                    Destroy(pipe);
                    pipes.Remove(pipe);
                    break; // Exit the loop to avoid modifying a collection while iterating
                }
            }
        }
    }

    void Flap()
    {
        // Apply force to make the bird jump
        rb.velocity = new Vector2(rb.velocity.x, jumpForce);
    }

    void SpawnPipe()
    {
        GameObject newPipe = Instantiate(pipePrefab, pipeSpawnPoint.position, Quaternion.identity);
        pipes.Add(newPipe);
    }

    bool IsCollidingWithPipe(GameObject pipe)
    {
        Collider2D pipeCollider = pipe.GetComponent<Collider2D>();
        return pipeCollider != null && pipeCollider.bounds.Intersects(GetComponent<Collider2D>().bounds);
    }

    bool IsCollidingWithGround(GameObject ground)
    {
        Collider2D groundCollider = ground.GetComponent<Collider2D>();
        return groundCollider != null && groundCollider.bounds.Intersects(GetComponent<Collider2D>().bounds);
    }

    void EndGame()
    {
        // Implement game over logic (e.g., display score, restart menu)
        Debug.Log("Game Over!");
    }
}

O script Unity fornecido representa um jogo Flappy Bird simplificado, onde o pássaro controlado pelo jogador navega por um ambiente de rolagem. O pássaro pode pular mediante entrada do usuário, e o jogo verifica colisões com canos e com o solo, acionando um game over se detectado. Os canos são gerados dinamicamente em intervalos regulares e se movem em direção ao jogador. O script inclui lógica para remover canos que saem da visão da câmera para otimizar o desempenho. A função 'EndGame' é chamada mediante colisão, e pode ser expandida para lidar com vários cenários de game over, como exibir uma pontuação ou reiniciar o jogo. O código visa oferecer uma implementação básica da mecânica Flappy Bird dentro de um ambiente Unity.

Etapa 6: UI e menus

• Crie uma interface de usuário para exibir a pontuação.
• Crie menus para iniciar e reiniciar o jogo.

Etapa 7: ajuste fino da jogabilidade

• Ajuste a física e a velocidade do jogo para uma experiência equilibrada e agradável.
• Teste e repita seu jogo para garantir uma jogabilidade suave e desafiadora.

Etapa 8: Adicionar efeitos sonoros

• Importe ou crie efeitos sonoros para batidas, pontuações e colisões.
• Integre esses efeitos sonoros ao seu jogo.

Exemplo de modificações para adicionar efeitos sonoros em 'FlappyBird.cs':

using UnityEngine;
using System.Collections.Generic;

public class FlappyBird : MonoBehaviour
{
    // Existing variables...

    public AudioClip jumpSound;
    public AudioClip collisionSound;
    public AudioClip gameOverSound;

    private AudioSource audioSource;

    void Start()
    {
        // Existing Start() code...

        // Add AudioSource component and reference
        audioSource = gameObject.AddComponent<AudioSource>();
    }

    void Flap()
    {
        // Apply force to make the bird jump
        rb.velocity = new Vector2(rb.velocity.x, jumpForce);

        // Play jump sound
        audioSource.PlayOneShot(jumpSound);
    }

    void EndGame()
    {
        // Play game over sound
        audioSource.PlayOneShot(gameOverSound);

        // Implement other game over logic...
    }

    // Existing code...
}

Etapa 9: construir e implantar

• Crie seu jogo para sua plataforma de destino (iOS, Android, etc.).
• Implante e teste no dispositivo ou emulador escolhido.

Conclusão

Este tutorial abrange os passos essenciais para recriar este clássico jogo Flappy Bird em Unity. Experimente recursos e melhorias adicionais para tornar o jogo seu. Feliz desenvolvimento de jogo!