Hvordan lage et Flappy Bird-inspirert spill i Unity

I denne Unity opplæringen går vi gjennom prosessen med å lage et Flappy Bird-spill. Dette klassiske mobilspillet innebærer å lede en fugl gjennom en rekke rør ved å trykke for å få den til å klaffe og unngå hindringer. La oss dykke ned i trinn-for-trinn-instruksjonene.

Trinn 1: Sett opp Unity-prosjektet ditt

• Hvis du ikke har gjort det ennå, åpne Unity og lag et nytt 2D-prosjekt.
• Sett opp prosjektinnstillingene dine, inkludert oppløsning og plattformmålretting.

Trinn 2: Importer spillressurser

• Finn eller lag ressurser for fuglen, rørene og bakgrunnen.
• Importer disse ressursene til Unity-prosjektet ditt.

Trinn 3: Lag Flappy Bird

• Legg til en 2D sprite for fuglen.
• Implementer enkle trykkkontroller for å lage fugleklaffen.
• Påfør tyngdekraften for å få fuglen til å falle naturlig.

Trinn 4: Design rørene

• Lag et rør prefab ved å bruke 2D-sprites.
• Sett opp et spawn-system for å generere rør med jevne mellomrom.

Trinn 5: Implementer spilllogikk

• Legg til et poengsystem for vellykket gjennomføring av rør.
• Implementer kollisjonsdeteksjon for å avslutte spillet når fuglen treffer rør eller bakken.

Sjekk skriptet nedenfor, det innkapsler del 3, 4 og 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ølgende Unity-skriptet representerer et forenklet Flappy Bird-spill, der den spillerkontrollerte fuglen navigerer gjennom et rullemiljø. Fuglen kan hoppe på brukerinndata, og spillet sjekker for kollisjoner med både rør og bakken, og utløser et spill over hvis det oppdages. Pipes gytes dynamisk med jevne mellomrom og beveger seg mot spilleren. Skriptet inkluderer logikk for å fjerne rør som går utenfor kameravisningen for å optimalisere ytelsen. 'EndGame'-funksjonen kalles ved kollisjon, og den kan utvides til å håndtere ulike game-over-scenarier, for eksempel å vise en poengsum eller starte spillet på nytt. Koden tar sikte på å tilby en grunnleggende implementering av Flappy Bird-mekanikk i et Unity-miljø.

Trinn 6: UI og menyer

• Design et brukergrensesnitt for å vise poengsummen.
• Lag menyer for å starte og starte spillet på nytt.

Trinn 7: Finjuster spillingen

• Juster spillet fysikk og hastigheten for en balansert og hyggelig opplevelse.
• Test og gjenta spillet ditt for å sikre jevn og utfordrende spilling.

Trinn 8: Legg til lydeffekter

• Importer eller lag lydeffekter for blafring, scoring og kollisjoner.
• Integrer disse lydeffektene i spillet ditt.

Eksempler på endringer for å legge til lydeffekter 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...
}

Trinn 9: Bygg og distribuer

• Bygg spillet ditt for målplattformen din (iOS, Android, etc.).
• Distribuer og test på din valgte enhet eller emulator.

Konklusjon

Denne opplæringen dekker de essensielle trinnene for å gjenskape dette klassiske Flappy Bird-spillet i Unity. Eksperimenter med tilleggsfunksjoner og forbedringer for å gjøre spillet ditt eget. God spillutvikling!