यूनिटी में फ्लैपी बर्ड से प्रेरित गेम कैसे बनाएं

इस Unity ट्यूटोरियल में, हम फ्लैपी बर्ड गेम बनाने की प्रक्रिया से गुजरेंगे। इस क्लासिक मोबाइल गेम में पाइप की एक श्रृंखला के माध्यम से एक पक्षी को मार्गदर्शन करना शामिल है, ताकि वह फड़फड़ाए और बाधाओं से बच सके। आइए चरण-दर-चरण निर्देशों में गोता लगाएँ।

चरण 1: अपना Unity प्रोजेक्ट सेट करें

• यदि आपने अभी तक ऐसा नहीं किया है, तो Unity खोलें और एक नया 2D प्रोजेक्ट बनाएं।
• रिज़ॉल्यूशन और प्लेटफ़ॉर्म लक्ष्यीकरण सहित अपनी प्रोजेक्ट सेटिंग सेट करें.

चरण 2: गेम एसेट्स आयात करें

• पक्षी, पाइप और पृष्ठभूमि के लिए संपत्तियां खोजें या बनाएं.
• इन परिसंपत्तियों को अपने Unity प्रोजेक्ट में आयात करें.

चरण 3: फ्लैपी बर्ड बनाएं

• पक्षी के लिए 2D स्प्राइट जोड़ें।
• पक्षी को फड़फड़ाने के लिए सरल नल नियंत्रण लागू करें।
• पक्षी को स्वाभाविक रूप से नीचे गिराने के लिए गुरुत्वाकर्षण का प्रयोग करें।

चरण 4: पाइपों का डिज़ाइन तैयार करें

• 2D स्प्राइट्स का उपयोग करके एक पाइप प्रीफ़ैब बनाएँ।
• नियमित अंतराल पर पाइप उत्पन्न करने के लिए स्पॉन प्रणाली स्थापित करें।

चरण 5: गेम लॉजिक को लागू करें

• पाइपों से सफलतापूर्वक गुजरने के लिए स्कोरिंग प्रणाली जोड़ें।
• जब पक्षी पाइप या जमीन से टकराता है तो खेल को समाप्त करने के लिए टकराव का पता लगाने की प्रणाली लागू करें।

नीचे दी गई स्क्रिप्ट देखें, यह भाग 3, 4 और 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!");
    }
}

प्रदान की गई Unity स्क्रिप्ट एक सरलीकृत फ्लैपी बर्ड गेम का प्रतिनिधित्व करती है, जहाँ खिलाड़ी द्वारा नियंत्रित पक्षी स्क्रॉलिंग वातावरण में नेविगेट करता है। पक्षी उपयोगकर्ता के इनपुट पर कूद सकता है, और खेल पाइप और जमीन दोनों के साथ टकराव की जाँच करता है, यदि पता चला तो खेल खत्म हो जाता है। पाइप नियमित अंतराल पर गतिशील रूप से उत्पन्न होते हैं और खिलाड़ी की ओर बढ़ते हैं। स्क्रिप्ट में प्रदर्शन को अनुकूलित करने के लिए कैमरा दृश्य से बाहर जाने वाले पाइप को हटाने का तर्क शामिल है। टकराव होने पर 'EndGame' फ़ंक्शन को कॉल किया जाता है, और इसे विभिन्न गेम-ओवर परिदृश्यों को संभालने के लिए विस्तारित किया जा सकता है, जैसे कि स्कोर प्रदर्शित करना या गेम को फिर से शुरू करना। कोड का उद्देश्य Unity वातावरण के भीतर फ्लैपी बर्ड मैकेनिक्स का एक बुनियादी कार्यान्वयन प्रदान करना है।

चरण 6: यूआई और मेनू

• स्कोर प्रदर्शित करने के लिए UI डिज़ाइन करें.
• खेल को शुरू करने और पुनः आरंभ करने के लिए मेनू बनाएँ।

चरण 7: गेमप्ले को बेहतर बनाएं

• संतुलित और आनंददायक अनुभव के लिए खेल की भौतिकी और गति को समायोजित करें।
• सुचारू और चुनौतीपूर्ण गेमप्ले सुनिश्चित करने के लिए अपने गेम का परीक्षण और पुनरावृत्ति करें।

चरण 8: ध्वनि प्रभाव जोड़ें

• आयात करें या फड़फड़ाहट, स्कोरिंग और टकराव के लिए ध्वनि प्रभाव बनाएं।
• इन ध्वनि प्रभावों को अपने खेल में एकीकृत करें।

'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...
}

चरण 9: निर्माण और तैनाती

• अपने लक्ष्य प्लेटफ़ॉर्म (iOS, Android, आदि) के लिए अपना गेम बनाएं।
• अपने चुने हुए डिवाइस या एमुलेटर पर तैनात करें और परीक्षण करें।

निष्कर्ष

यह ट्यूटोरियल इस क्लासिक फ्लैपी बर्ड गेम को Unity में फिर से बनाने के लिए आवश्यक चरणों को कवर करता है। गेम को अपना बनाने के लिए अतिरिक्त सुविधाओं और सुधारों के साथ प्रयोग करें। गेम डेवलपमेंट की शुभकामनाएँ!