यूनिटी के लिए अंतहीन धावक ट्यूटोरियल

वीडियो गेम में दुनिया चाहे कितनी भी बड़ी क्यों न हो, उसका अंत हमेशा होता है। लेकिन कुछ गेम अनंत दुनिया का अनुकरण करने की कोशिश करते हैं, ऐसे गेम एंडलेस रनर नामक श्रेणी में आते हैं ।

एंडलेस रनर एक प्रकार का खेल है जिसमें खिलाड़ी लगातार आगे बढ़ता रहता है, अंक एकत्रित करता है और बाधाओं से बचता है। मुख्य उद्देश्य बाधाओं में गिरे या उनसे टकराए बिना स्तर के अंत तक पहुँचना है, लेकिन कई बार, स्तर खुद को अनंत बार दोहराता है, धीरे-धीरे कठिनाई बढ़ाता है, जब तक कि खिलाड़ी बाधा से टकरा नहीं जाता।

यह देखते हुए कि आधुनिक कंप्यूटर/गेमिंग उपकरणों की प्रसंस्करण शक्ति भी सीमित है, एक वास्तविक अनंत विश्व बनाना असंभव है।

तो कुछ गेम अनंत दुनिया का भ्रम कैसे पैदा करते हैं? इसका जवाब है बिल्डिंग ब्लॉक्स का दोबारा इस्तेमाल करके (जिसे ऑब्जेक्ट पूलिंग भी कहते हैं), दूसरे शब्दों में, जैसे ही ब्लॉक कैमरा व्यू के पीछे या बाहर जाता है, उसे आगे की ओर ले जाया जाता है।

में एक अंतहीन धावक खेल बनाने के लिए Unity, हमें बाधाओं और एक खिलाड़ी नियंत्रक के साथ एक मंच बनाने की आवश्यकता होगी।

चरण 1: प्लेटफ़ॉर्म बनाएं

हम एक टाइलयुक्त प्लेटफॉर्म बनाकर शुरुआत करते हैं जिसे बाद में प्रीफ़ैब में संग्रहीत किया जाएगा:

• एक नया गेमऑब्जेक्ट बनाएं और उसे कॉल करें "TilePrefab"
• नया क्यूब बनाएं (गेमऑब्जेक्ट -> 3D ऑब्जेक्ट -> क्यूब)
• क्यूब को "TilePrefab" ऑब्जेक्ट के अंदर ले जाएं, इसकी स्थिति को (0, 0, 0) में बदलें, और स्केल को (8, 0.4, 20) में बदलें

• वैकल्पिक रूप से आप अतिरिक्त क्यूब्स बनाकर किनारों पर रेल्स जोड़ सकते हैं, जैसे:

बाधाओं के लिए, मेरे पास 3 प्रकार की बाधाएं होंगी, लेकिन आप आवश्यकतानुसार जितनी चाहें उतनी बना सकते हैं:

• ऑब्जेक्ट के अंदर 3 गेमऑब्जेक्ट बनाएं "TilePrefab" और उन्हें नाम दें "Obstacle1", "Obstacle2" और "Obstacle3"
• पहली बाधा के लिए, एक नया क्यूब बनाएं और उसे "Obstacle1" ऑब्जेक्ट के अंदर ले जाएं
• नए क्यूब को प्लेटफॉर्म के बराबर चौड़ाई में स्केल करें और इसकी ऊंचाई को कम करें (खिलाड़ी को इस बाधा से बचने के लिए कूदना होगा)
• एक नई सामग्री बनाएं, इसे नाम दें "RedMaterial" और इसका रंग बदलकर लाल कर दें, फिर इसे क्यूब को सौंप दें (यह सिर्फ इसलिए है ताकि बाधा मुख्य प्लेटफॉर्म से अलग दिखाई दे)

• कुछ क्यूब्स बनाएं "Obstacle2" और उन्हें त्रिकोणीय आकार में रखें, नीचे एक खुला स्थान छोड़ दें (खिलाड़ी को इस बाधा से बचने के लिए झुकना होगा)

• और अंत में, और "Obstacle3" का डुप्लिकेट होने जा रहा है, एक साथ संयुक्त "Obstacle1" "Obstacle2"

• अब बाधाओं के अंदर सभी वस्तुओं का चयन करें और उनके टैग को बदलें "Finish", बाद में खिलाड़ी और बाधा के बीच टकराव का पता लगाने के लिए इसकी आवश्यकता होगी।

एक अनंत प्लेटफ़ॉर्म बनाने के लिए हमें कुछ स्क्रिप्ट की आवश्यकता होगी जो ऑब्जेक्ट पूलिंग और बाधा सक्रियण को संभाल सकें:

• एक नई स्क्रिप्ट बनाएं, उसे कॉल करें "SC_PlatformTile" और उसके अंदर नीचे दिया गया कोड पेस्ट करें:

SC_प्लेटफॉर्मटाइल.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SC_PlatformTile : MonoBehaviour
{
    public Transform startPoint;
    public Transform endPoint;
    public GameObject[] obstacles; //Objects that contains different obstacle types which will be randomly activated

    public void ActivateRandomObstacle()
    {
        DeactivateAllObstacles();

        System.Random random = new System.Random();
        int randomNumber = random.Next(0, obstacles.Length);
        obstacles[randomNumber].SetActive(true);
    }

    public void DeactivateAllObstacles()
    {
        for (int i = 0; i < obstacles.Length; i++)
        {
            obstacles[i].SetActive(false);
        }
    }
}

• एक नई स्क्रिप्ट बनाएं, उसे कॉल करें "SC_GroundGenerator" और उसके अंदर नीचे दिया गया कोड पेस्ट करें:

SC_ग्राउंडजेनरेटर.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

public class SC_GroundGenerator : MonoBehaviour
{
    public Camera mainCamera;
    public Transform startPoint; //Point from where ground tiles will start
    public SC_PlatformTile tilePrefab;
    public float movingSpeed = 12;
    public int tilesToPreSpawn = 15; //How many tiles should be pre-spawned
    public int tilesWithoutObstacles = 3; //How many tiles at the beginning should not have obstacles, good for warm-up

    List<SC_PlatformTile> spawnedTiles = new List<SC_PlatformTile>();
    int nextTileToActivate = -1;
    [HideInInspector]
    public bool gameOver = false;
    static bool gameStarted = false;
    float score = 0;

    public static SC_GroundGenerator instance;

    // Start is called before the first frame update
    void Start()
    {
        instance = this;

        Vector3 spawnPosition = startPoint.position;
        int tilesWithNoObstaclesTmp = tilesWithoutObstacles;
        for (int i = 0; i < tilesToPreSpawn; i++)
        {
            spawnPosition -= tilePrefab.startPoint.localPosition;
            SC_PlatformTile spawnedTile = Instantiate(tilePrefab, spawnPosition, Quaternion.identity) as SC_PlatformTile;
            if(tilesWithNoObstaclesTmp > 0)
            {
                spawnedTile.DeactivateAllObstacles();
                tilesWithNoObstaclesTmp--;
            }
            else
            {
                spawnedTile.ActivateRandomObstacle();
            }
            
            spawnPosition = spawnedTile.endPoint.position;
            spawnedTile.transform.SetParent(transform);
            spawnedTiles.Add(spawnedTile);
        }
    }

    // Update is called once per frame
    void Update()
    {
        // Move the object upward in world space x unit/second.
        //Increase speed the higher score we get
        if (!gameOver && gameStarted)
        {
            transform.Translate(-spawnedTiles[0].transform.forward * Time.deltaTime * (movingSpeed + (score/500)), Space.World);
            score += Time.deltaTime * movingSpeed;
        }

        if (mainCamera.WorldToViewportPoint(spawnedTiles[0].endPoint.position).z < 0)
        {
            //Move the tile to the front if it's behind the Camera
            SC_PlatformTile tileTmp = spawnedTiles[0];
            spawnedTiles.RemoveAt(0);
            tileTmp.transform.position = spawnedTiles[spawnedTiles.Count - 1].endPoint.position - tileTmp.startPoint.localPosition;
            tileTmp.ActivateRandomObstacle();
            spawnedTiles.Add(tileTmp);
        }

        if (gameOver || !gameStarted)
        {
            if (Input.GetKeyDown(KeyCode.Space))
            {
                if (gameOver)
                {
                    //Restart current scene
                    Scene scene = SceneManager.GetActiveScene();
                    SceneManager.LoadScene(scene.name);
                }
                else
                {
                    //Start the game
                    gameStarted = true;
                }
            }
        }
    }

    void OnGUI()
    {
        if (gameOver)
        {
            GUI.color = Color.red;
            GUI.Label(new Rect(Screen.width / 2 - 100, Screen.height / 2 - 100, 200, 200), "Game Over\nYour score is: " + ((int)score) + "\nPress 'Space' to restart");
        }
        else
        {
            if (!gameStarted)
            {
                GUI.color = Color.red;
                GUI.Label(new Rect(Screen.width / 2 - 100, Screen.height / 2 - 100, 200, 200), "Press 'Space' to start");
            }
        }


        GUI.color = Color.green;
        GUI.Label(new Rect(5, 5, 200, 25), "Score: " + ((int)score));
    }
}

• SC_PlatformTile स्क्रिप्ट को "TilePrefab" ऑब्जेक्ट से जोड़ें
• "Obstacle1", "Obstacle2" और "Obstacle3" ऑब्जेक्ट को बाधाओं की सरणी में असाइन करें

प्रारंभ बिंदु और अंत बिंदु के लिए, हमें 2 गेमऑब्जेक्ट बनाने की आवश्यकता है जिन्हें क्रमशः प्लेटफॉर्म के प्रारंभ और अंत में रखा जाना चाहिए:

• SC_PlatformTile में प्रारंभ बिंदु और अंत बिंदु चर निर्दिष्ट करें

• ऑब्जेक्ट को प्रीफ़ैब में सहेजें "TilePrefab" और उसे दृश्य से हटाएँ
• एक नया गेमऑब्जेक्ट बनाएं और उसे कॉल करें "_GroundGenerator"
• SC_GroundGenerator स्क्रिप्ट को "_GroundGenerator" ऑब्जेक्ट से जोड़ें
• मुख्य कैमरा की स्थिति को (10, 1, -9) में बदलें और इसके रोटेशन को (0, -55, 0) में बदलें
• एक नया गेमऑब्जेक्ट बनाएं, उसे कॉल करें "StartPoint" और उसकी स्थिति को (0, -2, -15) में बदलें
• ऑब्जेक्ट का चयन करें "_GroundGenerator" और SC_GroundGenerator में मुख्य कैमरा, स्टार्ट पॉइंट और टाइल प्रीफ़ैब वैरिएबल निर्दिष्ट करें

अब प्ले बटन दबाएँ और देखें कि प्लेटफ़ॉर्म कैसे चलता है। जैसे ही प्लेटफ़ॉर्म टाइल कैमरे के दृश्य से बाहर जाती है, इसे वापस अंत में ले जाया जाता है और एक यादृच्छिक बाधा सक्रिय हो जाती है, जिससे अनंत स्तर का भ्रम पैदा होता है (0:11 पर जाएँ)।

कैमरे को वीडियो के समान ही रखा जाना चाहिए, ताकि प्लेटफॉर्म कैमरे की ओर और उसके पीछे जाएं, अन्यथा प्लेटफॉर्म दोहराए नहीं जाएंगे।

चरण 2: प्लेयर बनाएं

खिलाड़ी का उदाहरण एक साधारण क्षेत्र होगा जो कूदने और झुकने की क्षमता वाले नियंत्रक का उपयोग करेगा।

• एक नया स्फीयर बनाएं (गेमऑब्जेक्ट -> 3D ऑब्जेक्ट -> स्फीयर) और इसके स्फीयर कोलाइडर घटक को हटा दें
• "RedMaterial" पहले से बनाए गए को इसमें असाइन करें
• एक नया गेमऑब्जेक्ट बनाएं और उसे कॉल करें "Player"
• गोले को "Player" वस्तु के अंदर ले जाएं और इसकी स्थिति को (0, 0, 0) में बदलें
• एक नई स्क्रिप्ट बनाएं, उसे कॉल करें "SC_IRPlayer" और उसके अंदर नीचे दिया गया कोड पेस्ट करें:

SC_IRPlayer.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[RequireComponent(typeof(Rigidbody))]

public class SC_IRPlayer : MonoBehaviour
{
    public float gravity = 20.0f;
    public float jumpHeight = 2.5f;

    Rigidbody r;
    bool grounded = false;
    Vector3 defaultScale;
    bool crouch = false;

    // Start is called before the first frame update
    void Start()
    {
        r = GetComponent<Rigidbody>();
        r.constraints = RigidbodyConstraints.FreezePositionX | RigidbodyConstraints.FreezePositionZ;
        r.freezeRotation = true;
        r.useGravity = false;
        defaultScale = transform.localScale;
    }

    void Update()
    {
        // Jump
        if (Input.GetKeyDown(KeyCode.W) && grounded)
        {
            r.velocity = new Vector3(r.velocity.x, CalculateJumpVerticalSpeed(), r.velocity.z);
        }

        //Crouch
        crouch = Input.GetKey(KeyCode.S);
        if (crouch)
        {
            transform.localScale = Vector3.Lerp(transform.localScale, new Vector3(defaultScale.x, defaultScale.y * 0.4f, defaultScale.z), Time.deltaTime * 7);
        }
        else
        {
            transform.localScale = Vector3.Lerp(transform.localScale, defaultScale, Time.deltaTime * 7);
        }
    }

    // Update is called once per frame
    void FixedUpdate()
    {
        // We apply gravity manually for more tuning control
        r.AddForce(new Vector3(0, -gravity * r.mass, 0));

        grounded = false;
    }

    void OnCollisionStay()
    {
        grounded = true;
    }

    float CalculateJumpVerticalSpeed()
    {
        // From the jump height and gravity we deduce the upwards speed 
        // for the character to reach at the apex.
        return Mathf.Sqrt(2 * jumpHeight * gravity);
    }

    void OnCollisionEnter(Collision collision)
    {
        if(collision.gameObject.tag == "Finish")
        {
            //print("GameOver!");
            SC_GroundGenerator.instance.gameOver = true;
        }
    }
}

• SC_IRPlayer स्क्रिप्ट को ऑब्जेक्ट से जोड़ें "Player" (आप देखेंगे कि इसमें Rigidbody नामक एक अन्य घटक भी जोड़ा गया है)
• "Player" ऑब्जेक्ट में BoxCollider घटक जोड़ें

• वस्तु को कैमरे के ठीक सामने, वस्तु से "Player" थोड़ा ऊपर रखें "StartPoint"

प्ले दबाएँ और कूदने के लिए W कुंजी और झुकने के लिए S कुंजी का उपयोग करें। उद्देश्य लाल बाधाओं से बचना है:

इस क्षितिज झुकने शेडर की जाँच करें.