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

इस पाठ में, हम Cave Engine के Logic Bricks का उपयोग करके वस्तु एकत्र करने के लिए लॉजिक बनाएंगे।

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

यह एक बहुत आम गेमप्ले सिस्टम: वस्तु इंटरैक्शन का आरंभ है। इसी विचार को बाद में सिक्के, चाबियाँ, गोला-बारूद, स्वास्थ्य वस्तुएँ, Quest वस्तुएँ, पॉवर-अप, या कोई अन्य वस्तु जो खिलाड़ी एकत्र कर सकता है, बनाने के लिए विस्तारित किया जा सकता है।

1. वस्तु को एकत्र करने के लिए लॉजिक बनाना

हमारे Player की लॉजिक के अंदर, हम एकत्र करने योग्य वस्तुओं के साथ टकराव का पता सीधे खिलाड़ी से करेंगे।

गतिष्ति लॉजिक के बाद, हम उस प्रणाली को बनाएंगे जो वस्तु के साथ संपर्क का पता लगाने और उसे दृश्य से हटाने के लिए जिम्मेदार होगी।

सबसे पहले, Entity प्राप्त करें और Get Character का उपयोग करके इसके Character Component तक पहुँचें।

Character Component से, Get Collision With नोड का उपयोग करें। यह नोड हमें एक विशेष Tag के आधार पर टकराव का पता लगाने की अनुमति देता है।

इस मामले में, हम टैग item का उपयोग करेंगे, जिसे पिछले पाठ में हमारे एकत्र करने योग्य वस्तु को सौंपा गया था।

इसीलिए वस्तु को टैग करना महत्वपूर्ण था। विशेष Entity नाम की जांच करने के बजाय, हम बस खिलाड़ी से पूछ सकते हैं कि क्या उसने item टैग के साथ किसी चीज़ के साथ टकराव किया। यह लॉजिक को अधिक लचीला बनाता है, क्योंकि कोई भी एकत्र करने योग्य वस्तु जो उसी टैग के साथ हो, उसे उसी प्रणाली द्वारा पता लगाया जा सकता है।

इस पहचान का परिणाम एक Get नोड से जुड़ना चाहिए, जो टकराव की जानकारी वापस देता है, जिसे Collision Info भी कहा जाता है।

फिर हम इंडेक्स 0 प्राप्त करते हैं, जो पहले पहचाने गए टकराव का प्रतिनिधित्व करता है।

अंत में, इस परिणाम को Kill नोड से जोड़ें, जो दृश्य से एक Entity को हटाने के लिए जिम्मेदार है।

जिस Entity को हटाया जाएगा वह सीधे Collision Info से आएगा। दूसरे शब्दों में, एकत्र की गई वस्तु को Kill में इनपुट के रूप में पास किया गया है, जिससे इसे खिलाड़ी द्वारा छूने पर दृश्य से गायब किया जाएगा।

इस लॉजिक के साथ, खिलाड़ी पहले से ही एक एकत्र करने योग्य वस्तु का पता लगा सकता है और इसे दृश्य से हटा सकता है।

व्यवहार में, इसका अर्थ है कि जब खिलाड़ी item टैग के साथ किसी Entity को छूता है, तो वह Entity एकत्र की जाएगी और वर्तमान दृश्य से हटा दी जाएगी।

2. एकत्र करने योग्य UI बनाना

अब हमें खिलाड़ी को यह दिखाना है कि वास्तव में एक वस्तु एकत्र की गई है।

इसके लिए, हम एक सरल UI इंटरफ़ेस बनाएंगे जो दिखाता है:

• वस्तु का आइकन
• एकत्र की गई वस्तुओं की संख्या
• मानचित्र में उपलब्ध कुल वस्तुओं की संख्या

शुरुआत करने के लिए, Player Template को पहुँचें और एक Interface घटक, विशेष रूप से एक UI Element जोड़ें। यह UI Element हमारे HUD के दृश्य भाग को बनाने के लिए जिम्मेदार होगा।

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

UI Element के Basic टैब में, हम आइकन की स्थिति और पैमाना कॉन्फ़िगर कर सकते हैं।

स्थिति संपत्ति के एंकर आइकन पर क्लिक करके, आप इसे स्क्रीन के नीचे-बाएँ कोने पर स्थिर कर सकते हैं।

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

अंत में, Layer मान को 2 पर सेट करें। यह सुनिश्चित करता है कि आइकन अन्य UI Elements से ऊपर प्रस्तुत किया जाएगा जिनकी प्राथमिकता कम है।

Scale मूल्यों को समायोजित करें जब तक आइकन वह आकार नहीं ले लेता जो आप चाहते हैं।

फिर इसे स्क्रीन के बाएँ तरफ या किसी अन्य क्षेत्र में स्थानांतरित करने के लिए Position मूल्यों का उपयोग करें जहां आप इंटरफेस के अंदर इसे पसंद करते हैं।

ये सेटिंग्स आपको HUD में तत्व के आकार और स्थिति को सटीक रूप से नियंत्रित करने की अनुमति देती हैं।

Behaviour टैब में, हम डिफ़ॉल्ट विधि को हटाकर एक कस्टम Texture जोड़ सकते हैं।

आप इच्छित दृश्य परिणाम प्राप्त करने के लिए Tint रंग और Alpha पारदर्शिता को भी समायोजित कर सकते हैं।

9-Slice Scaling विकल्प का उपयोग छवि के आकार को बिना विकृत किए लेआउट में फैला देता है। जब सक्षम होता है, तो आप इसकी मानों को आइकन की आवश्यकताओं के अनुसार समायोजित कर सकते हैं, यहां तक कि फिर से आकार दिया गया। हमारी स्थिति में, हम 9-Slice का उपयोग नहीं करेंगे क्योंकि हमारी छवि एक आइकन है।

अब चलिए Text प्रकार के 3 नए इंटरफेस Entities बनाते हैं।

वे एकत्र की गई वस्तुओं की संख्या और मानचित्र में उपलब्ध कुल वस्तुओं को प्रदर्शित करने के लिए जिम्मेदार होंगे।

सबसे पहले, पहले Text का नाम TextCollect रखें। यह टेक्स्ट खिलाड़ी द्वारा एकत्र किए गए वस्तुओं की संख्या प्रदर्शित करेगा।

फिर, दूसरे Text में केवल "/" कैरेक्टर होगा, जो UI में मूल्यों के बीच दृश्य विभाजक के रूप में कार्य करेगा।

अंततः, तीसरे Text का नाम TextMax होगा। यह मानचित्र में उपलब्ध अधिकतम मात्रा का प्रतिनिधित्व करेगा।

अब UI Elements के Text टैब में पहुँचें।

इस अनुभाग में, एक फ़ील्ड है जहाँ हम स्क्रीन पर प्रदर्शित होने वाली सामग्री को परिभाषित कर सकते हैं।

दो टेक्स्ट जो वस्तु मानों का प्रतिनिधित्व करते हैं, TextMax और TextCollect, उनके प्रारंभिक मान को 0 पर बनाए रखें।

separator के लिए उपयोग किया जाने वाला टेक्स्ट केवल "/" कैरेक्टर होना चाहिए, जो एकत्र की गई मात्रा को कुल वस्तुओं की मात्रा से दृश्य रूप से अलग करता है।

अब चलिए UI टेक्स्ट को इस तरह से व्यवस्थित करें कि वे आइकन के बगल में हों।

• सबसे पहले, TextCollect को स्थान दें।
• फिर इसके बाद "/" पाठ रखें।
• अंत में, TextMax को स्लैश के बाद रखें।

इस तरह, UI एक प्रगति काउंटर की तरह सुव्यवस्थित होगा, जो स्पष्ट रूप से कुछ इस तरह प्रदर्शित करता है:

एकत्र की गई वस्तुएं / कुल वस्तुएं

उदाहरण के लिए:

0 / 10

नोट: वैकल्पिक रूप से, आप एकल Entity भी बना सकते हैं और प्रोग्रामेटिकली (Logic Bricks के माध्यम से), स्ट्रिंग को जोड़ सकते हैं ताकि समान परिणाम प्राप्त किया जा सके।

3. आइटम काउंटर लॉजिक बनाना

अब हमें UI को एकत्र की गई वस्तुओं को दर्शाने की आवश्यकता है।

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

सबसे पहले, Player Logic Brick पर वापस जाएं और एक नई प्रॉपर्टी बनाएं जिसका नाम Collected Item है, प्रकार Int।

यह प्रॉपर्टी सीधे गेम के दौरान खिलाड़ी द्वारा एकत्र की गई वस्तुओं की संख्या को संग्रहित करेगी।

इस प्रॉपर्टी का प्रारंभिक मान 0 होना चाहिए।

प्लेयर लॉजिक में, वह Kill नोड के बाद जो एकत्र की गई वस्तु को हटा देता है, हम उस लॉजिक को बनाएंगे जो वस्तु की गिनती को अपडेट करने के लिए जिम्मेदार है।

सबसे पहले, Collected Item प्रॉपर्टी प्राप्त करें।

फिर इसके वर्तमान मान में +1 जोड़ें।

अंत में, परिणाम को Collected Item प्रॉपर्टी में पुनः सेट करें।

इस तरह, हर बार जब खिलाड़ी एक वस्तु एकत्र करता है, तो Collected Item का मान 1 से बढ़ता है, जिससे काउंटर अपडेट रहता है।

हालांकि, यह मान अभी भी केवल प्रॉपर्टी में संग्रहित है। अब हमें इसे UI टेक्स्ट में प्रदर्शित करने की आवश्यकता है।

उसके तुरंत बाद, Set Collected Item से एक फ़्लो को Set Text नोड से जोड़ें।

यह नोड UI में प्रदर्शित किए गए टेक्स्ट को अपडेट करने के लिए जिम्मेदार होगा।

Set Text का उपयोग करने के लिए, हमें दो चीजें प्रदान करने की आवश्यकता है:

• वह UI Element Component जिसका टेक्स्ट अपडेट किया जाएगा
• नया टेक्स्ट मान

चूंकि टेक्स्ट खिलाड़ी के बच्चों के रूप में बनाए गए थे, हम सीधे Entity संरचना के माध्यम से उन्हें एक्सेस कर सकते हैं।

इसके लिए, Entity का उपयोग करें, फिर Get Child करें, टेक्स्ट ऑब्जेक्ट का नाम दें। Recursive विकल्प को सक्षम करें ताकि सुनिश्चित हो सके कि खोजना प्लेयर के बच्चों के बच्चों के अंदर भी हो।

फिर उस Entity से UI Element Component प्राप्त करें जो पाया गया।

टेक्स्ट मान के लिए, Collected Item प्रॉपर्टी प्राप्त करें, इसे String में परिवर्तित करें और इसे Set Text से जोड़ें।

इस तरह, UI टेक्स्ट अपने भीतर संग्रहित मान के साथ अपने आप अपडेट हो जाएगा।

अब हमें कुल वस्तुओं की संख्या का प्रतिनिधित्व करने वाले टेक्स्ट को भी कार्यशील बनाना है।

अभी भी खिलाड़ी लॉजिक ब्रिक्स में, एक नई प्रॉपर्टी बनाएं जिसका नाम Max Item है, प्रकार Int।

यह प्रॉपर्टी मानचित्र में उपलब्ध कुल एकत्र करने योग्य वस्तुओं की संख्या को संग्रहित करेगी।

अब, इस प्रॉपर्टी में मानचित्र में कुल वस्तुओं की संख्या संग्रहित करने के लिए, हम प्लेयर के On Start इवेंट का उपयोग करेंगे।

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

सबसे पहले, गेम के Scene को प्राप्त करें।

फिर उस नोड का उपयोग करें जो item टैग द्वारा फ़िल्टर की गई दृश्य में सभी Entities लौटाता है। चूंकि यह टैग हमारे एकत्र करने योग्य वस्तुओं में केवल मौजूद है, यह वर्तमान मानचित्र में सभी एकत्र करने योग्य वस्तुओं की सूची लौटाएगा।

Entities की इस सूची के साथ, Size नोड का उपयोग करें।

Size नोड सूची में कुल तत्वों की संख्या को पूर्णांक के रूप में लौटाता है। यह मान ठीक यह दर्शाता है कि मानचित्र में कितनी वस्तुएं मौजूद हैं।

अंत में, इस परिणाम को Max Item प्रॉपर्टी में सेट करें, यह सुनिश्चित करते हुए कि गेम को Max Item में एकत्र करने योग्य वस्तुओं की सही कुल मात्रा के साथ आरंभ किया जाए।

अब हमें केवल इस मान को UI टेक्स्ट में भेजने की आवश्यकता है।

इसके लिए, हम वही लॉजिक प्रयोग करेंगे जो हमने एकत्रित वस्तु के लिए उपयोग किया था।

मैक्स आइटम प्रॉपर्टी प्राप्त करें, मान को स्ट्रिंग में परिवर्तित करें, और इसे सेट टेक्स्ट नोड से कनेक्ट करें।

फिर खिलाड़ी हायरेक्री से गेट चाइल्ड का उपयोग करके अधिकतम आइटम टेक्स्ट के संबंधित यूआई एलिमेंट तक पहुंचें, सही नाम टाइप करें और यदि आवश्यक हो तो रेकर्सिव को सक्षम करें।

अंत में, उस यूआई एलिमेंट कंपोनेंट को सेट टेक्स्ट से कनेक्ट करें।

इस तरीके से, कुल आइटम की संख्या खिलाड़ी इंटरफेस में सही तरीके से प्रदर्शित होगी।

इस समय, संग्रहणीय वस्तु प्रणाली कार्यात्मक है।

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