दृश्य स्क्रिप्टिंग ट्यूटोरियल (लॉजिक ब्रिक्स)

इस पाठ में, हम पिछले पाठ में शुरू की गई प्रणाली को समाप्त करेंगे, बटन बनाकर जो प्लेटफार्म लॉजिक से जुड़ेंगे और दोनों प्रणालियों के बीच इंटरैक्शन को पूरा करेंगे।

इस प्रक्रिया के दौरान, हम Cave के दृश्य लॉजिक सिस्टम में कई महत्वपूर्ण अवधारणाओं का अन्वेषण करेंगे। आप सीखेंगे कि Rigid Body का उपयोग करके टकराव कैसे जांचा जाता है, समय के साथ क्रियाओं को नियंत्रित करने के लिए Delay नोड का उपयोग करें, गेमप्ले के दौरान एक Entity का रंग कैसे बदलें, और अपने लॉजिक ब्रिक्स को व्यवस्थित और पुन: प्रयोज्य रखने के लिए functions बनाना और उनका उपयोग करना भी अभ्यास करेंगे।

इस पाठ के अंत तक, हमारे पास एक पूर्ण प्रणाली होगी जहां बटन को खिलाड़ी द्वारा सक्रिय किया जा सकता है और पिछले में बनाई गई प्लेटफार्म के साथ सही ढंग से संवाद कर सकता है।

1. बटन बनाना

बटन बनाने की प्रक्रिया शुरू करने के लिए, पहले एक नया Entity Template बनाएं।

फिर, इसके उद्देश्य के अनुसार Entity का नाम बदलें, उस Mesh को कॉन्फ़िगर करें जिसका उपयोग इसके दृश्य प्रतिनिधित्व के लिए किया जाएगा, और आवश्यक भौतिक तत्व जोड़ें ताकि यह खेल के अंदर सही ढंग से इंटरैक्ट कर सके।

इसके बाद, एक नया Logic Brick बनाएं और इसे बटन Entity से लिंक करें।

यह प्रक्रिया उस समान है जो हमने पहले प्लेटफार्म बनाते समय की थी, इसलिए यह भी उन अवधारणाओं का अभ्यास करने का एक अच्छा अवसर है जो आपने पहले सीखी हैं।

इस चरण के अंत में, हमारे पास बटन की सक्रियता लॉजिक प्राप्त करने के लिए तैयार बुनियादी संरचना होगी।

अब, एक बहुत महत्वपूर्ण चरण है: हमें बटन Entity में button टैग जोड़ना नहीं भूलना चाहिए।

यदि आप याद करते हैं, पिछले पाठ में हमने पहले ही प्लेटफार्म लॉजिक को इस विशेष टैग का उपयोग करके स्वचालित रूप से यह गिनने के लिए तैयार किया है कि दृश्यमान में कितने बटन हैं।

इसलिए, इस टैग को बनाया जाना चाहिए और इसे बटन को उसी नाम से सौंपा जाना चाहिए जिसका उपयोग प्लेटफार्म लॉजिक में किया गया था।

यदि टैग का नाम अलग है, भले ही एक छोटे से विवरण से, प्लेटफार्म बटन को सही ढंग से नहीं खोज पाएगा और गिनती ठीक से काम नहीं करेगी।

इसलिए, आगे बढ़ने से पहले, सुनिश्चित करें कि आप button टैग बनाते हैं और इसे बटन Entity में जोड़ते हैं।

अब आइए बटन Entity में एक संपत्ति भी जोड़ते हैं।

हम मैप के अंदर बटन की पहचान के लिए button टैग का उपयोग करते हैं, लेकिन हम इसके व्यवहार का एक भाग नियंत्रित करने के लिए एक संपत्ति का उपयोग करेंगे।

Active Time नामक एक नई संपत्ति बनाएं, जिसका प्रकार Float हो।

यह संपत्ति बताएगी कि बटन सक्रिय रहते हुए कितनी देर तक सक्रिय रहना चाहिए उसके बाद स्वचालित रूप से निष्क्रिय अवस्था में लौटना चाहिए।

इससे प्रणाली अधिक लचीली हो जाती है क्योंकि प्रत्येक बटन सक्रियता के लिए भिन्न समय हो सकता है। उदाहरण के लिए, एक बटन 3 सेकंड के लिए सक्रिय रह सकता है, जबकि दूसरा बटन 10 सेकंड तक सक्रिय रह सकता है, बिना लॉजिक ब्रिक को बदलें।

2. बटन लॉजिक बनाना

अब जब हमारी Entity तैयार है, टैग और संपत्ति कॉन्फ़िगर की गई है, तो चलिए बटन के व्यवहार को बनाना शुरू करते हैं।

पहला कदम बटन Entity और खिलाड़ी के बीच टकराव का पता लगाना है, ताकि हम इसे सक्रिय कर सकें जब खिलाड़ी इसे छुए।

हालांकि, इस लॉजिक को लागू करने से पहले, हमें एक महत्वपूर्ण विवरण पर विचार करना होगा: हम केवल चाहते हैं कि बटन तब सक्रिय हो जब यह वर्तमान में निष्क्रिय है।

चूंकि बटन के पास दो अलग-अलग राज्य होंगे, active और inactive, हमें यह स्टोर करने का एक तरीका चाहिए कि वर्तमान में कौन सा राज्य उपयोग किया जा रहा है।

इसके लिए, बटन Logic Brick में एक नई संपत्ति बनाएं जिसे Active Button कहा जाता है, जिसका प्रकार Boolean हो।

यह संपत्ति बटन का वर्तमान राज्य स्टोर करेगी, यह दर्शाते हुए कि यह सक्रिय है या नहीं। हम अगले चरणों में इस मान का उपयोग पूरी बटन के व्यवहार को नियंत्रित करने के लिए करेंगे।

अब हम दृश्य लॉजिक बनाना शुरू कर सकते हैं।

On Update में, हम लगातार जांचेंगे कि बटन सक्रिय है या निष्क्रिय है, जिस पर हम अभी बनाए गए Active Button संपत्ति का उपयोग करेंगे।

इसके लिए, इसका मान प्राप्त करने के लिए Get Active Button का उपयोग करें और इसके राज्य की जांच के लिए If नोड का उपयोग करें।

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

इसके लिए, Collided With नोड जोड़ें।

इस नोड को एक Rigid Body Component की आवश्यकता है, इसलिए बटन Entity को ले लें और इसके माध्यम से भौतिकी को कॉन्फ़िगर करते समय जोड़े गए Rigid Body Component को प्राप्त करें।

हमें यह भी बताना होगा कि हम किस वस्तु का पता लगाना चाहते हैं। इसके लिए, चरित्र पर एक player टैग जोड़ें और इसे Collided With को पास करें।

इस तरह, टकराव को केवल तब ही मान्य माना जाएगा जब बटन खिलाड़ी के साथ टकराता है।

इस संरचना के साथ, बटन को केवल तब सक्रिय किया जा सकता है जब यह निष्क्रिय हो और जब खिलाड़ी वास्तव में इसके साथ टकराता है।

अब जब हमारे पास दोनों रास्ते परिभाषित हैं, तो चलिए पहले उस लॉजिक को लागू करते हैं जब बटन सक्रिय है।

इसके बाद, हम इसे सक्रिय करने के लिए जिम्मेदार व्यवहार बनाएंगे।

इसके लिए, उस True स्थिति का पालन करें जो बताती है कि बटन सक्रिय है या नहीं।

इस प्रवाह में, हम बटन Entity में बनाई गई Active Time संपत्ति का उपयोग करेंगे यह नियंत्रित करने के लिए कि बटन कितनी देर तक सक्रिय रहना चाहिए।

पहले, बटन Entity प्राप्त करें और इसके गुण प्राप्त करने के लिए Get Properties नोड का उपयोग करें।

फिर Get Property का उपयोग करें, पूर्ववर्ती रूप से लौटाए गए शब्दकोष को जोड़कर और Active Time को Key के रूप में उपयोग करें।

चूंकि यह संपत्ति Float है, Get Property के आउटपुट प्रकार को Float में बदलें, यह सुनिश्चित करते हुए कि हम इस मान का अगले भाग में सही ढंग से उपयोग कर सकें।

अब Get Property का आउटपुट Active Time संपत्ति का मान लौटाता है, जो यह निर्धारित करता है कि बटन कितनी देर तक सक्रिय रहेगा।

इसके बाद, Delay नोड जोड़ें और इस मान का उपयोग अवधि के रूप में करें।

इस प्रकार, प्रतीक्षा समय सीधे Entity संपत्ति द्वारा नियंत्रित होता है, जिससे विभिन्न बटन सक्रियता समय अलग-अलग हो सकते हैं बिना लॉजिक को बदले।

Delay समाप्त होने के बाद, Set Active Button का उपयोग करें और उसके मान को False पर सेट करें।

इससे, बटन अपने संपत्ति में निर्दिष्ट समय के बाद स्वचालित रूप से निष्क्रिय अवस्था में लौट आता है।

बहुत अच्छा। अब चलिए दूसरे रास्ते का अनुसरण करते हैं और बटन को सक्रिय करने के लिए ज़िम्मेदार व्यवहार बनाते हैं।

Collided With नोड का आउटपुट एक Bool मान लौटाता है।

जब यह मान True होता है, तो इसका मतलब है कि बटन खिलाड़ी के साथ टकरा गया।

उस क्षण में, हम सिर्फ Set Active Button का उपयोग कर सकते हैं और इसके मान को True पर सेट कर सकते हैं।

इससे, बटन सक्रिय अवस्था में प्रवेश करता है और पहले से बनाए गए सक्रिय लॉजिक का उपयोग करना शुरू करता है, जो इसे एक निश्चित समय के लिए सक्रिय रखता है और फिर फिर से निष्क्रिय कर देता है।

इससे, हमने एक पूर्ण व्यवहार चक्र बनाया:

• जब खिलाड़ी बटन के साथ टकराता है, यह सक्रिय होता है
• Active Time में निर्दिष्ट समय के बाद, यह निष्क्रिय हो जाता है
• उसके बाद, इसे एक और टकराव द्वारा फिर से सक्रिय किया जा सकता है

हालांकि यह लॉजिक सरल है, यह बटन को पहले से ही दो अलग-अलग राज्य प्रदान करता है और वह आधार बनेगा जो हम अगले फीचर जोड़ने जा रहे हैं।

सब कुछ काम कर रहा है, लेकिन एक महत्वपूर्ण हिस्सा अभी भी गायब है।

हालांकि बटन सक्रियण और निष्क्रियकरण लॉजिक सही ढंग से कार्य कर रहा है, लेकिन हमारा प्लेटफार्म अभी भी यह नहीं जानता कि कब कोई बटन सक्रिय हुआ।

यह ठीक वहीं है जहाँ Button Count संपत्ति जो हमने पूर्व में Scene में बनाई थी, महत्वपूर्ण हो जाती है।

यदि आप याद करते हैं, हमने प्लेटफार्म लॉजिक में परिभाषित किया था कि प्लेटफार्म केवल तब हटा दिया जाना चाहिए जब इस संपत्ति का मान मानचित्र में बटन की कुल संख्या के बराबर हो।

अन्य शब्दों में, प्लेटफार्म पहले से ही प्रतिक्रिया देने के लिए तैयार है, लेकिन अब तक कोई बटन इस मान को नहीं बदल रहा है।

अब हमें जो करने की आवश्यकता है, वह यह है कि बटन सक्रिय और निष्क्रिय होने पर सीधे Button Count संपत्ति को Scene में संशोधित करने की अनुमति दें।

यह Cave में लॉजिक ब्रिक्स की एक और बहुत महत्वपूर्ण विशेषता का अभ्यास करने का एक बड़ा अवसर है: functions बनाना।

एक ही लॉजिक को कई बार दोहराने के बजाय, हम इस व्यवहार को पुन: प्रयोज्य कार्यों में संकुचित करेंगे, जो हमारे ग्राफ को अधिक संगठित रखता है, समझने में आसान, और बनाए रखने में आसान बनाता है।

चूंकि Button Count संपत्ति Scene में संग्रहित होती है, हम पहले इसे एक्सेस करने की आवश्यकता है।

इसके लिए, Get Scene का उपयोग करें, और फिर Get Properties का उपयोग करें।

3. दृश्य संपत्तियों को नियंत्रित करने वाला फ़ंक्शन बनाना

इन नोडों से, हम एक फ़ंक्शन बनाएंगे।

इसके लिए, शामिल नोड्स का चयन करें, राइट-क्लिक करें, और Promote Selection to Function चुनें।

फिर नई फ़ंक्शन का नाम एक स्पष्ट और वर्णनात्मक नाम बदलें जो इसे प्रोजेक्ट लॉजिक के अंदर उसके उद्देश्य का प्रतिनिधित्व करता है।

इस मामले में, हम Set Scene Property नाम का उपयोग करेंगे।

अब चलिए Set Scene Property फ़ंक्शन का तरीका संरचना करें।

पहले, Scene गुणों के शब्दकोष को Get Property नोड के लिए पास करें। यह शब्दकोष Get Scene → Get Properties प्रवाह से आता है।

फिर Get Property का आउटपुट Int में बदलें, यह सुनिश्चित करते हुए कि हम पूर्णांक मानों के साथ काम कर रहे हैं।

Function Inputs में, इस फ़ंक्शन के लिए दो नए पैरामीटर बनाएं:

• Prop Name, जिसका प्रकार String हो
• Value, जिसका प्रकार Int हो

प्रॉप नाम पैरामीटर को की के रूप में गेट प्रॉपर्टी में उपयोग किया जाएगा, जिससे फ़ंक्शन को दृश्य प्रॉपर्टीज़ शब्दकोश के अंदर वांछित प्रॉपर्टी तक पहुँचने की अनुमति मिलेगी।

फिर हम इस प्रॉपर्टी को सेट प्रॉपर्टी का उपयोग करके अपडेट करेंगे।

इसके लिए, प्रॉपर्टी का वर्तमान मान प्राप्त करें, उसमें मान इनपुट जोड़ें, और परिणाम को उसी प्रॉपर्टी में वापस लिखें।

हम दृश्य प्रॉपर्टीज़ शब्दकोश को फिर से पास करते हैं और प्रॉप नाम को कुंजी के रूप में उपयोग करते हैं।

यह एक सामान्य और पुन: प्रयोज्य फ़ंक्शन बनाता है जो दृश्य प्रॉपर्टीज़ को एक साधारण और संगठित तरीके से संशोधित कर सकता है।

एक निश्चित मान सेट करने के बजाय, यह फ़ंक्शन एक वृद्धि प्रणाली की तरह काम करता है: यह प्राप्त मान को दृश्य प्रॉपर्टी के वर्तमान मान में जोड़ता है।

इस फ़ंक्शन के तैयार होने के साथ, हमें अब मुख्य ग्राफ में सीधे उस पूरी श्रृंखला के नोड्स को बनाए रखने की आवश्यकता नहीं है।

अब, सभी लॉजिक को दोहराने के बजाय, हम बस फ़ंक्शन को ऐक्टिव बटन को सत्य पर सेट करने के बाद कॉल करते हैं।

इसका मतलब यह है कि जब बटन सक्रिय होता है, तो हम तुरंत मंच लॉजिक को बताते हैं कि एक और बटन दबाया गया है।

इसके लिए, प्रॉपर्टी नाम बटन काउंट पास करें, जो दृश्य में संग्रहीत प्रॉपर्टी है, और वृद्धि के रूप में मान 1 भेजें।

यह फ़ंक्शन स्वचालित रूप से उस प्रॉपर्टी के वर्तमान मान में +1 जोड़ देगा।

इस तरह, कोई भी सक्रिय बटन सीधे सिस्टम के वैश्विक प्रगति को अपडेट करता है, बिना लॉजिक को दोहराए।

यह हमें भविष्य में दृश्य प्रॉपर्टीज़ को संशोधित करने के लिए अधिक लचीलापन भी देता है, इस ही फ़ंक्शन को फिर से उपयोग करके।

यह दिखाने के लिए कि यह कितनी सरल और लचीला है, चलिए सक्रिय बटन लॉजिक पर वापस लौटते हैं।

सक्रियता का समय समाप्त होने के बाद और हम ऐक्टिव बटन को झूठा पर सेट करने के बाद, हम फिर से सेट सीन प्रॉपर्टी कॉल करेंगे।

प्रॉप नाम पैरामीटर बटन काउंट होगा, वही दृश्य प्रॉपर्टी का उपयोग करते हुए।

लेकिन इस बार, मान पैरामीटर -1 होगा।

चूंकि हमारा फ़ंक्शन प्राप्त मान को वर्तमान दृश्य प्रॉपर्टी मान में जोड़ता है, नकारात्मक संख्या को पास करने से स्वचालित रूप से वर्तमान बटन काउंट से 1 घट जाता है।

इस तरह, जब भी कोई बटन निष्क्रिय होता है, तब प्रणाली भी वैश्विक प्रगति को सही तरीके से अपडेट करती है, जिससे मंच लॉजिक मानचित्र में बटनों की वास्तविक स्थिति के साथ समन्वित रहता है।

अब हमारी लॉजिक अपेक्षित रूप से काम कर रही है।

बस एक महत्वपूर्ण विवरण बचा है: एक दृश्य प्रभाव बनाना जिससे खिलाड़ी को स्पष्ट हो सके कि बटन सक्रिय है।

जब भी एक बटन सक्रिय होता है, हम सीधे इसके रंग को टिंट का उपयोग करके बदलेंगे, इसके स्थिति को दृश्य रूप से उजागर करते हैं।

ऐक्टिव बटन को सत्य पर सेट करने से पहले, एक अनुक्रम जोड़ें।

चूंकि हमें अब तीन प्रवाहों की आवश्यकता नहीं है, हम दाएँ-क्लिक करके और अंतिम प्रवाह आउटपुट हटाएँ चुनकर एक आउटपुट को हटा सकते हैं, केवल दो पथ रखकर।

फिर बटन के बच्चे एंटिटी को बटनमेश कहा जाता है, इसके मैश कंपोनेंट तक पहुँचें, और टिंट मान को समायोजित करें।

Y अक्ष में, मान को 25 पर सेट करें, जिससे बटन सक्रिय होने पर हरा दिखे।

यह खिलाड़ी को स्पष्ट दृश्य प्रतिक्रिया देता है जब भी बटन दबाया जाता है, खेल के अंदर इंटरैक्शन की पठनीयता और प्रतिक्रियाशीलता को सुधारता है।

इसी तरह, जब बटन निष्क्रिय हो जाता है, तो हम उसके मूल रंग को बहाल करेंगे।

उसी लॉजिक का उपयोग करें, लेकिन उस प्रवाह में जहाँ हम ऐक्टिव बटन को झूठा पर सेट करते हैं।

उस क्षण में, बच्चे एंटिटी बटनमेश तक फिर से पहुँचें, इसके मैश कंपोनेंट को प्राप्त करें, और टिंट मान को समायोजित करें।

डिफ़ॉल्ट रंग पर लौटने के लिए, सभी टिंट मानों को फिर से 1 पर सेट करें, बटन की मूल दृश्य स्थिति को बहाल करते हुए।

इस तरह, जब भी बटन निष्क्रिय होता है, तो यह भी अपनी प्रारंभिक उपस्थिति पर लौटता है, यह स्पष्ट करते हुए कि इसे फिर से सक्रिय किया जा सकता है।

एक बटन टेम्पलेट उदाहरण का चयन करके जिसे हमने दृश्य में जोड़ा है, हम इसके प्रॉपर्टीज़ तक पहुँच सकते हैं और ऐक्टिव टाइम के मान को बदल सकते हैं।

इस तरह, प्रत्येक बटन की सक्रियण अवधि अलग हो सकती है और स्वतंत्रता से कार्य कर सकती है।

यह हमें स्तर के भीतर विविध चुनौतियों को बनाने के लिए अधिक लचीलापन देता है, क्योंकि प्रत्येक बटन को मुख्य प्रणाली की लॉजिक को बदले बिना व्यक्तियों के अनुसार कॉन्फ़िगर किया जा सकता है।

इसके साथ, हम मानचित्र में जितनी चाहें उतने बटन जोड़ सकते हैं, प्रत्येक के पास अलग-अलग सक्रियण समय और स्वतंत्र व्यवहार होता है।

मंच स्वचालित रूप से इस सेटअप का पालन करता है बिना मैन्युअल समायोजन की आवश्यकता के, क्योंकि गिनती रनटाइम पर की जाती है।

प्रणाली भी खेल की वास्तविक स्थिति के साथ समन्वित रहती है। जैसे-जैसे बटन सक्रिय और निष्क्रिय होते हैं, वैश्विक मान обновित होता है, और मंच तब प्रतिक्रिया करता है जब शर्त पूरी होती है, सही क्षण पर दृश्य से हटा दिया जाता है।

लॉजिक के अलावा, हमने खिलाड़ी के लिए महत्वपूर्ण दृश्य प्रतिक्रिया जोड़ी है।

जब बटन सक्रिय होता है तो उसका रंग बदलना और निष्क्रिय होने पर उसकी मूल उपस्थिति को बहाल करना प्रणाली को बहुत स्पष्ट और अधिक सहज बना देता है। खिलाड़ी स्पष्ट रूप से समझ सकता है कि कौन से बटन सक्रिय हैं और कौन से बटन अभी भी ध्यान देने की आवश्यकता है।

आखिर में, हमने एक मॉड्यूलर और स्केलेबल सिस्टम तैयार किया है जो एंटिटीज़ के बीच संचार, दृश्य के माध्यम से केंद्रीकृत नियंत्रण, और खेल की दुनिया में सीधे दृश्य प्रतिक्रिया को जोड़ता है।

इस ही संरचना को दरवाजों, मंचों, लिफ्टों, पहेलियों, जालों, समयबद्ध चुनौतियों, और कई अन्य इंटरैक्टिव घटनाओं के लिए आसानी से विस्तारित किया जा सकता है।