Jak stworzyć grę inspirowaną Flappy Bird w Unity

W tym samouczku Unity przejdziemy przez proces tworzenia gry Flappy Bird. Ta klasyczna gra mobilna polega na prowadzeniu ptaka przez serię rur poprzez stukanie, aby trzepotał i unikał przeszkód. Zanurzmy się w instrukcjach krok po kroku.

Krok 1: Skonfiguruj swój projekt Unity

• Jeśli jeszcze tego nie zrobiłeś, otwórz Unity i utwórz nowy projekt 2D.
• Skonfiguruj ustawienia projektu, uwzględniając rozdzielczość i docelową platformę.

Krok 2: Importuj zasoby gry

• Znajdź lub utwórz zasoby dla ptaka, rur i tła.
• Zaimportuj te zasoby do swojego projektu Unity.

Krok 3: Stwórz Flappy Bird

• Dodaj dwuwymiarowego duszka ptaka.
• Zastosuj proste sterowanie dotykowe, aby ptak trzepotał skrzydłami.
• Wykorzystaj grawitację, aby ptak spadł naturalnie.

Krok 4: Zaprojektuj rury

• Utwórz rurę prefab używając sprite'ów 2D.
• Skonfiguruj system generowania rur w regularnych odstępach czasu.

Krok 5: Wdrażanie logiki gry

• Dodaj system punktacji za pomyślne przejście przez rury.
• Wprowadź wykrywanie kolizji, aby zakończyć grę, gdy ptak uderzy w rury lub ziemię.

Sprawdź poniższy skrypt, który obejmuje części 3, 4 i 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!");
    }
}

Dostarczony skrypt Unity przedstawia uproszczoną grę Flappy Bird, w której ptak kontrolowany przez gracza porusza się po przewijanym środowisku. Ptak może skakać po wprowadzeniu danych przez użytkownika, a gra sprawdza kolizje z rurami i ziemią, uruchamiając koniec gry, jeśli zostaną wykryte. Rury są dynamicznie generowane w regularnych odstępach czasu i poruszają się w kierunku gracza. Skrypt zawiera logikę usuwania rur, które wychodzą poza pole widzenia kamery, aby zoptymalizować wydajność. Funkcja 'EndGame' jest wywoływana po kolizji i może być rozszerzona, aby obsługiwać różne scenariusze zakończenia gry, takie jak wyświetlanie wyniku lub ponowne uruchamianie gry. Kod ma na celu zaoferowanie podstawowej implementacji mechaniki Flappy Bird w środowisku Unity.

Krok 6: Interfejs użytkownika i menu

• Zaprojektuj interfejs użytkownika do wyświetlania wyniku.
• Utwórz menu służące do uruchamiania i ponownego uruchamiania gry.

Krok 7: Dopracuj rozgrywkę

• Dostosuj fizykę i szybkość gry, aby uzyskać zrównoważoną i przyjemną rozgrywkę.
• Testuj i udoskonalaj swoją grę, aby zapewnić jej płynną i trudną rozgrywkę.

Krok 8: Dodaj efekty dźwiękowe

• Importuj lub stwórz efekty dźwiękowe dla machania skrzydłami, punktacji i kolizji.
• Zintegruj te efekty dźwiękowe ze swoją grą.

Przykładowe modyfikacje mające na celu dodanie efektów dźwiękowych w '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...
}

Krok 9: Kompilacja i wdrożenie

• Stwórz grę przeznaczoną na platformę docelową (iOS, Android itp.).
• Wdróż i przetestuj na wybranym urządzeniu lub emulatorze.

Wniosek

Ten samouczek obejmuje podstawowe kroki, aby odtworzyć tę klasyczną grę Flappy Bird w Unity. Eksperymentuj z dodatkowymi funkcjami i ulepszeniami, aby uczynić grę swoją. Udanego tworzenia gry!