Hoe maak je een Flappy Bird-geïnspireerd spel in Unity

In deze Unity tutorial, zullen we door het proces van het maken van een Flappy Bird game lopen. Deze klassieke mobiele game houdt in dat je een vogel door een serie pijpen leidt door te tikken om hem te laten flapperen en obstakels te vermijden. Laten we in de stapsgewijze instructies duiken.

Stap 1: Stel uw Unity-project in

Als je dat nog niet gedaan hebt, open dan Unity en maak een nieuw 2D-project.
Stel uw projectinstellingen in, inclusief resolutie en platformtargeting.

Stap 2: Game-assets importeren

Zoek of maak assets voor de vogel, pijpen en achtergrond.
Importeer deze assets in uw Unity-project.

Stap 3: Maak de Flappy Bird

Voeg een 2D-sprite voor de vogel toe.
Gebruik eenvoudige tikbedieningen om de vogel te laten fladderen.
Gebruik de zwaartekracht om de vogel op natuurlijke wijze te laten vallen.

Stap 4: Ontwerp de pijpen

Maak een pijp prefab met behulp van 2D-sprites.
Richt een spawnsysteem in om met regelmatige tussenpozen pijpen te genereren.

Stap 5: Implementeer spellogica

Voeg een puntensysteem toe voor het succesvol passeren van leidingen.
Implementeer botsingsdetectie om het spel te beëindigen wanneer de vogel buizen of de grond raakt.

Bekijk het onderstaande script, het omvat de delen 3, 4 en 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!");
    }
}

Het meegeleverde Unity-script vertegenwoordigt een vereenvoudigd Flappy Bird-spel, waarbij de door de speler bestuurde vogel door een scrollende omgeving navigeert. De vogel kan springen op invoer van de gebruiker en het spel controleert op botsingen met zowel buizen als de grond, waardoor een game over wordt geactiveerd als deze worden gedetecteerd. Buizen worden dynamisch met regelmatige tussenpozen gespawnd en bewegen naar de speler toe. Het script bevat logica om buizen te verwijderen die buiten het camerabeeld gaan om de prestaties te optimaliseren. De 'EndGame'-functie wordt aangeroepen bij een botsing en kan worden uitgebreid om verschillende game-over-scenario's te verwerken, zoals het weergeven van een score of het opnieuw starten van het spel. De code is bedoeld om een basisimplementatie van Flappy Bird-mechanica te bieden binnen een Unity-omgeving.

Stap 6: UI en menu's

Ontwerp een gebruikersinterface voor het weergeven van de score.
Maak menu's voor het starten en herstarten van het spel.

Stap 7: Verbeter de gameplay

Pas de physics en snelheid van het spel aan voor een evenwichtige en plezierige ervaring.
Test en herhaal uw spel om een soepele en uitdagende gameplay te garanderen.

Stap 8: Geluidseffecten toevoegen

Importeer of maak geluidseffecten voor flapperen, scoren en botsingen.
Integreer deze geluidseffecten in uw spel.

Voorbeeldwijzigingen om geluidseffecten toe te voegen 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...
}

Stap 9: Bouwen en implementeren

Maak je game voor je doelplatform (iOS, Android, etc.).
Implementeer en test op het door u gekozen apparaat of de emulator.

Conclusie

Deze tutorial behandelt de essentiële stappen om deze klassieke Flappy Bird-game opnieuw te maken in Unity. Experimenteer met extra functies en verbeteringen om de game helemaal jouw eigen te maken. Veel plezier met het ontwikkelen van de game!

unity tutorial flappy bird geïnspireerd kloon spel ontwikkeling script fysica gamplay obstakel score implementatie