Hur man gör ett Flappy Bird-inspirerat spel i Unity

I denna Unity handledning går vi igenom processen att skapa ett Flappy Bird-spel. Detta klassiska mobilspel går ut på att guida en fågel genom en serie rör genom att knacka för att få den att klappa och undvika hinder. Låt oss dyka ner i steg-för-steg-instruktionerna.

Steg 1: Konfigurera ditt Unity-projekt

• Om du inte har gjort det ännu, öppna Unity och skapa ett nytt 2D-projekt.
• Ställ in dina projektinställningar, inklusive upplösning och plattformsinriktning.

Steg 2: Importera speltillgångar

• Hitta eller skapa tillgångar för fågeln, rören och bakgrunden.
• Importera dessa tillgångar till ditt Unity-projekt.

Steg 3: Skapa Flappy Bird

• Lägg till en 2D-sprite för fågeln.
• Implementera enkla tryckkontroller för att göra fågelfliken.
• Applicera gravitation för att få fågeln att falla naturligt.

Steg 4: Designa rören

• Skapa ett rör prefab med 2D-sprites.
• Sätt upp ett spawn-system för att generera pipes med jämna mellanrum.

Steg 5: Implementera spellogik

• Lägg till ett poängsystem för att lyckas passera genom rör.
• Implementera kollisionsdetektering för att avsluta spelet när fågeln träffar rör eller marken.

Kontrollera skriptet nedan, det kapslar in delar 3, 4 och 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!");
    }
}

Det medföljande Unity-skriptet representerar ett förenklat Flappy Bird-spel, där den spelarkontrollerade fågeln navigerar genom en rullningsmiljö. Fågeln kan hoppa på användarinmatning, och spelet letar efter kollisioner med både rör och marken, vilket utlöser ett spel över om det upptäcks. Rör skapas dynamiskt med jämna mellanrum och rör sig mot spelaren. Skriptet innehåller logik för att ta bort rör som går utanför kameravyn för att optimera prestandan. 'EndGame'-funktionen anropas vid kollision, och den kan utökas för att hantera olika game-over-scenarier, som att visa en poäng eller starta om spelet. Koden syftar till att erbjuda en grundläggande implementering av Flappy Bird-mekanik i en Unity-miljö.

Steg 6: UI och menyer

• Designa ett användargränssnitt för att visa poängen.
• Skapa menyer för att starta och starta om spelet.

Steg 7: Finjustera spelet

• Justera spel fysik och hastighet för en balanserad och njutbar upplevelse.
• Testa och upprepa ditt spel för att säkerställa smidigt och utmanande spel.

Steg 8: Lägg till ljudeffekter

• Importera eller skapa ljudeffekter för flaxande, poängsättning och kollisioner.
• Integrera dessa ljudeffekter i ditt spel.

Exempel på ändringar för att lägga till ljudeffekter i '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...
}

Steg 9: Bygg och distribuera

• Bygg ditt spel för din målplattform (iOS, Android, etc.).
• Implementera och testa på din valda enhet eller emulator.

Slutsats

Denna handledning täcker de väsentliga stegen för att återskapa detta klassiska Flappy Bird-spel i Unity. Experimentera med ytterligare funktioner och förbättringar för att göra spelet till ditt eget. Trevlig spelutveckling!