Sådan laver du et Flappy Bird-inspireret spil i Unity

I denne Unity tutorial vil vi gennemgå processen med at skabe et Flappy Bird-spil. Dette klassiske mobilspil involverer at lede en fugl gennem en række rør ved at trykke for at få den til at klappe og undgå forhindringer. Lad os dykke ned i trin-for-trin instruktionerne.

Trin 1: Konfigurer dit Unity-projekt

• Hvis du endnu ikke har gjort det, skal du åbne Unity og oprette et nyt 2D-projekt.
• Konfigurer dine projektindstillinger, inklusive opløsning og platformsmålretning.

Trin 2: Importer spilaktiver

• Find eller opret aktiver til fuglen, rørene og baggrunden.
• Importer disse aktiver til dit Unity-projekt.

Trin 3: Opret Flappy Bird

• Tilføj en 2D sprite til fuglen.
• Implementer enkle trykknapper for at få fuglen til at klappe.
• Anvend tyngdekraften for at få fuglen til at falde naturligt.

Trin 4: Design rørene

• Lav et rør prefab ved hjælp af 2D sprites.
• Opsæt et spawn-system til at generere rør med jævne mellemrum.

Trin 5: Implementer spillogik

• Tilføj et scoringssystem for succesfuld passage gennem rør.
• Implementer kollisionsdetektion for at afslutte spillet, når fuglen rammer rør eller jorden.

Tjek scriptet nedenfor, det indkapsler 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-script repræsenterer et forenklet Flappy Bird-spil, hvor den spillerkontrollerede fugl navigerer gennem et rullemiljø. Fuglen kan hoppe efter brugerinput, og spillet tjekker for kollisioner med både rør og jorden, hvilket udløser et spil, hvis det opdages. Rør affødes dynamisk med jævne mellemrum og bevæger sig mod spilleren. Scriptet indeholder logik til at fjerne rør, der går uden for kameravisningen for at optimere ydeevnen. 'EndGame'-funktionen kaldes ved kollision, og den kan udvides til at håndtere forskellige game-over-scenarier, såsom at vise en score eller genstarte spillet. Koden har til formål at tilbyde en grundlæggende implementering af Flappy Bird-mekanik i et Unity-miljø.

Trin 6: UI og menuer

• Design en brugergrænseflade til at vise resultatet.
• Opret menuer til at starte og genstarte spillet.

Trin 7: Finjuster gameplayet

• Juster spil fysik og hastighed for en afbalanceret og fornøjelig oplevelse.
• Test og gentag dit spil for at sikre glat og udfordrende gameplay.

Trin 8: Tilføj lydeffekter

• Importer eller skab lydeffekter til klap, scoring og kollisioner.
• Integrer disse lydeffekter i dit spil.

Eksempler på ændringer for at tilføje 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...
}

Trin 9: Byg og implementer

• Byg dit spil til din målplatform (iOS, Android osv.).
• Implementer og test på din valgte enhed eller emulator.

Konklusion

Denne tutorial dækker de væsentlige trin til at genskabe dette klassiske Flappy Bird-spil i Unity. Eksperimenter med yderligere funktioner og forbedringer for at gøre spillet til dit eget. God spiludvikling!