How to Make a Flappy Bird-Inspired Game in Unity

In this Unity tutorial, we'll walk through the process of creating a Flappy Bird game. This classic mobile game involves guiding a bird through a series of pipes by tapping to make it flap and avoid obstacles. Let's dive into the step-by-step instructions.

Step 1: Set Up Your Unity Project

• If you haven't yet, open Unity and create a new 2D project.
• Set up your project settings, including resolution and platform targeting.

Step 2: Import Game Assets

• Find or create assets for the bird, pipes, and background.
• Import these assets into your Unity project.

Step 3: Create the Flappy Bird

• Add a 2D sprite for the bird.
• Implement simple tap controls to make the bird flap.
• Apply gravity to make the bird fall naturally.

Step 4: Design the Pipes

• Create a pipe prefab using 2D sprites.
• Set up a spawn system to generate pipes at regular intervals.

Step 5: Implement Game Logic

• Add a scoring system for successfully passing through pipes.
• Implement collision detection to end the game when the bird hits pipes or the ground.

Check the script below, it encapsulates parts 3, 4, and 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!");
    }
}

The provided Unity script represents a simplified Flappy Bird game, where the player-controlled bird navigates through a scrolling environment. The bird can jump upon user input, and the game checks for collisions with both pipes and the ground, triggering a game over if detected. Pipes are dynamically spawned at regular intervals and move towards the player. The script includes logic to remove pipes that go outside the camera view to optimize performance. The 'EndGame' function is called upon collision, and it can be expanded to handle various game-over scenarios, such as displaying a score or restarting the game. The code aims to offer a basic implementation of Flappy Bird mechanics within a Unity environment.

Step 6: UI and Menus

• Design a UI for displaying the score.
• Create menus for starting and restarting the game.

Step 7: Fine-Tune Gameplay

• Adjust game physics and speed for a balanced and enjoyable experience.
• Test and iterate on your game to ensure smooth and challenging gameplay.

Step 8: Add Sound Effects

• Import or create sound effects for flapping, scoring, and collisions.
• Integrate these sound effects into your game.

Example modifications to add sound effects in '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...
}

Step 9: Build and Deploy

• Build your game for your target platform (iOS, Android, etc.).
• Deploy and test on your chosen device or emulator.

Conclusion

This tutorial covers the essential steps to recreate this classic Flappy Bird game in Unity. Experiment with additional features and improvements to make the game your own. Happy game development!