यूनिटी में स्टेल्थ मैकेनिक्स जोड़ना

स्टेल्थ मैकेनिक्स गेमप्ले सिस्टम हैं जो खिलाड़ियों को दुश्मनों द्वारा पता लगाए जाने से बचने की अनुमति देते हैं। *Assassin's Creed* या *Hitman* जैसे स्टील्थ-आधारित गेम में आम तौर पर इस्तेमाल किए जाने वाले इन मैकेनिक्स में विज़न कोन, ध्वनि पहचान, छिपने के स्थान और खिलाड़ी दृश्यता स्तर जैसी सुविधाएँ शामिल हैं। स्टेल्थ मैकेनिक्स को जोड़ने से रणनीतिक सोच को बढ़ावा देकर और सावधानीपूर्वक योजना बनाकर गेमप्ले को और अधिक आकर्षक बनाया जा सकता है।

इस ट्यूटोरियल में, हम Unity में बुनियादी स्टील्थ मैकेनिक्स बनाएंगे। खिलाड़ी उन दुश्मनों द्वारा पता लगाए जाने से बच जाएगा जिनके पास दृष्टि शंकु हैं। यदि खिलाड़ी शंकु में प्रवेश करता है, तो उन्हें पता चल जाएगा।

चरण 1: दृश्य सेट करना

एक सरल Unity दृश्य बनाकर आरंभ करें:

1. एक नया Unity प्रोजेक्ट बनाएं.
2. जमीन के रूप में काम करने के लिए एक Plane जोड़ें।
3. Player को दर्शाने के लिए एक 3D मॉडल (जैसे, एक कैप्सूल) जोड़ें।
4. Enemy को दर्शाने के लिए एक अन्य 3D मॉडल (जैसे, एक घन) जोड़ें।
5. खिलाड़ी और दुश्मन को विमान पर अलग-अलग स्थानों पर रखें।

चरण 2: शत्रु दृष्टि शंकु का निर्माण

हम शंकु के आकार वाले ट्रिगर क्षेत्र का उपयोग करके दुश्मन की दृष्टि का अनुकरण करेंगे:

1. पदानुक्रम में राइट-क्लिक करें और Create > 3D ऑब्जेक्ट > सिलेंडर चुनें।
2. इसके पैमाने को समायोजित करके सिलेंडर का आकार बदलकर उसे शंकु जैसा बनाएं (उदाहरण के लिए, X = 1, Y = 0.5, Z = 1)।
3. इसे इस प्रकार घुमाएं कि सपाट आधार आगे की ओर हो (उदाहरण के लिए, रोटेशन X = 90)।
4. इसे शत्रु गेमऑब्जेक्ट के संतान के रूप में संलग्न करें।
5. शंकु के Collider को Trigger पर सेट करें।
6. दुश्मन के दृष्टि क्षेत्र से मेल खाने के लिए पैमाने और स्थिति को समायोजित करें।

चरण 3: शत्रु पहचान स्क्रिप्ट लिखना

अब, आइए दृष्टि शंकु के भीतर खिलाड़ी का पता लगाने के लिए एक स्क्रिप्ट बनाएं:

1. EnemyVision नामक एक C# स्क्रिप्ट बनाएं।
2. स्क्रिप्ट को शत्रु गेमऑब्जेक्ट से संलग्न करें।
3. निम्नलिखित कोड का उपयोग करें:

using UnityEngine;

public class EnemyVision : MonoBehaviour
{
    public bool playerDetected = false;

    void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            playerDetected = true;
            Debug.Log("Player Detected!");
        }
    }

    void OnTriggerExit(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            playerDetected = false;
            Debug.Log("Player Lost!");
        }
    }
}

यह स्क्रिप्ट जाँचती है कि प्लेयर विज़न कोन में प्रवेश करता है या बाहर निकलता है। सुनिश्चित करें कि प्लेयर गेमऑब्जेक्ट में टैग Player है।

चरण 4: प्लेयर दृश्यता जोड़ना

इसके बाद, आइए पहचान को और अधिक गतिशील बनाने के लिए दृश्यता तंत्र को लागू करें। खिलाड़ी को झुकने या छिपने पर पहचानना कठिन होगा:

1. PlayerVisibility नामक एक नई स्क्रिप्ट बनाएं।
2. इसे प्लेयर गेमऑब्जेक्ट से जोड़ें।
3. निम्नलिखित कोड का उपयोग करें:

using UnityEngine;

public class PlayerVisibility : MonoBehaviour
{
    public float visibility = 1.0f; // Full visibility

    void Update()
    {
        // Reduce visibility when crouching (e.g., pressing "C")
        if (Input.GetKey(KeyCode.C))
        {
            visibility = 0.5f;
            Debug.Log("Crouching: Reduced visibility!");
        }
        else
        {
            visibility = 1.0f; // Default visibility
        }
    }
}

यह स्क्रिप्ट खिलाड़ी की दृश्यता के स्तर को उसके कार्यों के आधार पर समायोजित करती है। दुश्मन बाद में इस मान का उपयोग यह तय करने के लिए कर सकते हैं कि खिलाड़ी का पता कितनी आसानी से लगाया जा सकता है।

चरण 5: शत्रु पहचान को बढ़ाना

अब, आइए दृश्यता को पहचान के साथ जोड़ते हैं। EnemyVision स्क्रिप्ट को इस प्रकार संशोधित करें:

using UnityEngine;

public class EnemyVision : MonoBehaviour
{
    public bool playerDetected = false;

    void OnTriggerStay(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            PlayerVisibility playerVisibility = other.GetComponent<PlayerVisibility>();

            if (playerVisibility != null && playerVisibility.visibility > 0.75f)
            {
                playerDetected = true;
                Debug.Log("Player Detected with high visibility!");
            }
            else
            {
                Debug.Log("Player not visible enough to detect.");
            }
        }
    }

    void OnTriggerExit(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            playerDetected = false;
            Debug.Log("Player Lost!");
        }
    }
}

यह स्क्रिप्ट प्लेयर के दृश्यता स्तर का उपयोग यह निर्धारित करने के लिए करती है कि उनका पता लगाया गया है या नहीं।

चरण 6: स्टेल्थ मैकेनिक्स का परीक्षण

अपने सेटअप का परीक्षण करने के लिए:

1. Unity एडिटर में Play बटन दबाएँ।
2. पता लगाने के लिए खिलाड़ी को शत्रु के दृष्टि शंकु में ले जाएं।
3. दृश्यता कम करने के लिए क्राउच बटन (जैसे, "C") दबाएं और परीक्षण करें कि यह पहचान को कैसे प्रभावित करता है।

वैकल्पिक संवर्द्धन

आपकी गुप्तचर क्षमता को बढ़ाने के लिए यहां कुछ सुझाव दिए गए हैं:

• ध्वनि पहचान: एक ऐसा तंत्र जोड़ें जहां दुश्मन खिलाड़ी को उनके द्वारा की गई आवाज (जैसे, दौड़ना) के आधार पर पहचान सके।
• छिपने के स्थान: ऐसे छिपने के स्थान बनाएं जहां खिलाड़ी का पता न चल सके।
• दुश्मनों पर गश्त: यूनिटी के नेवमेश सिस्टम का उपयोग करके दुश्मनों को एक निर्धारित पथ पर गश्त करने के लिए प्रोग्राम करें।
• चेतावनी स्थितियाँ: शत्रुओं के लिए चेतावनी स्तर जोड़ें (जैसे, संदिग्ध, खोजी, आक्रामक)।

निष्कर्ष

हमने Unity में बुनियादी स्टील्थ मैकेनिक्स को लागू किया है, जिसमें विज़न कोन और दृश्यता स्तर शामिल हैं। ये सिस्टम अधिक जटिल स्टील्थ गेमप्ले के लिए आधार के रूप में काम कर सकते हैं। अपने गेम के लिए पूरी तरह से इमर्सिव स्टील्थ अनुभव बनाने के लिए अतिरिक्त सुविधाओं के साथ प्रयोग करें।