Hoe je in Unity een op Flappy Bird geïnspireerd spel maakt
In deze Unity tutorial doorlopen we het proces van het maken van een Flappy Bird-spel. Bij dit klassieke mobiele spel begeleid je een vogel door een reeks pijpen door erop te tikken om hem te laten flapperen en obstakels te vermijden. Laten we eens kijken naar de stapsgewijze instructies.
Stap 1: Stel uw Unity-project in
- Als je dat nog niet hebt gedaan, open dan Unity en maak een nieuw 2D-project.
- Stel uw projectinstellingen in, inclusief resolutie en platformtargeting.
Stap 2: Game-items importeren
- Zoek of maak middelen voor de vogel, pijpen en achtergrond.
- Importeer deze assets in uw Unity-project.
Stap 3: Maak de Flappy Bird
- Voeg een 2D-sprite toe voor de vogel.
- Implementeer eenvoudige tikbedieningen om de vogelflap te maken.
- Pas de zwaartekracht toe om de vogel op natuurlijke wijze te laten vallen.
Stap 4: Ontwerp de pijpen
- Maak een pijp prefab met behulp van 2D-sprites.
- Zet een spawn-systeem op om met regelmatige tussenpozen pijpen te genereren.
Stap 5: Implementeer spellogica
- Voeg een scoresysteem toe voor het succesvol passeren van pijpen.
- Implementeer botsingsdetectie om het spel te beëindigen wanneer de vogel pijpen of de grond raakt.
Controleer 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 na input van de gebruiker, en het spel controleert op botsingen met zowel pijpen als de grond, waardoor een game-over wordt geactiveerd als dit wordt gedetecteerd. Pijpen worden dynamisch met regelmatige tussenpozen uitgezet en bewegen in de richting van de speler. Het script bevat logica om leidingen te verwijderen die buiten het camerabeeld vallen om de prestaties te optimaliseren. De 'EndGame'-functie wordt aangeroepen bij een botsing en kan worden uitgebreid om verschillende game-over-scenario's aan te kunnen, zoals het weergeven van een score of het opnieuw starten van het spel. De code is bedoeld om een basisimplementatie van de Flappy Bird-mechanica aan te bieden binnen een Unity-omgeving.
Stap 6: gebruikersinterface en menu's
- Ontwerp een gebruikersinterface voor het weergeven van de partituur.
- Creëer menu's voor het starten en herstarten van het spel.
Stap 7: Verfijn de gameplay
- Pas het spel fysica en de snelheid aan voor een evenwichtige en plezierige ervaring.
- Test en herhaal uw game om een soepele en uitdagende gameplay te garanderen.
Stap 8: Voeg geluidseffecten toe
- Importeer of creëer geluidseffecten voor fladderen, scoren en botsingen.
- Integreer deze geluidseffecten in je game.
Voorbeeldaanpassingen 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
- Bouw uw game voor uw doelplatform (iOS, Android, enz.).
- Implementeer en test op het door u gekozen apparaat of emulator.
Conclusie
Deze tutorial behandelt de essentiële stappen om dit klassieke Flappy Bird-spel opnieuw te maken in Unity. Experimenteer met extra functies en verbeteringen om het spel je eigen te maken. Veel spelontwikkeling!