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

इस पाठ में, हम खेल के अंदर घटनाओं को सक्रिय करने के लिए एक नया तरीका खोजने जा रहे हैं।

संग्रहणीय वस्तुओं के बजाय, हम एक ऐसा सिस्टम बनाएंगे जो बटनों पर आधारित होगा, जिन्हें खिलाड़ी द्वारा सक्रिय किया जाना आवश्यक है ताकि एक प्लेटफॉर्म को छोड़ने या किसी अन्य क्रिया को निष्पादित करने के लिए।

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

इस पहले भाग में, हम प्लेटफॉर्म लॉजिक बनाएंगे और सीखेंगे कि Scene में सीधे संग्रहीत गुणों का उपयोग कैसे करें।

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

इस उदाहरण में, बटन एक मान को बढ़ाएंगे जो Scene में संग्रहीत है, और प्लेटफॉर्म यह जानने के लिए उसी मान को पढ़ेगा कि सभी बटन सक्रिय हुए हैं।

1. प्लेटफॉर्म बनाना

पहले, जिस तरह से हमने पिछले पाठों में सीखा, चलिए हमारे प्लेटफॉर्म के लिए एक नया Entity Template बनाते हैं।

प्रोजेक्ट की शैली और आवश्यकताओं के अनुसार प्लेटफॉर्म की दृश्य प्रस्तुति के लिए उपयोग की जाने वाली Mesh को कॉन्फ़िगर करें।

फिर टकराव को जोड़ें और कॉन्फ़िगर करें, ताकि Player सही ढंग से दृश्य के अंदर प्लेटफॉर्म के साथ इंटरैक्ट कर सके।

इस उदाहरण में, प्लेटफॉर्म को किसी विशेष Tag या Property की आवश्यकता नहीं होगी, क्योंकि सक्रियण लॉजिक अगले चरणों में बनाए जाने वाले सिस्टम के अन्य तत्वों द्वारा नियंत्रित किया जाएगा।

2. प्लेटफॉर्म लॉजिक बनाना

अब चलिए एक नया Logic Brick बनाते हैं और इसे हमारे प्लेटफॉर्म Entity से लिंक करते हैं।

इस Logic Brick के भीतर, हम प्लेटफॉर्म के व्यवहार को नियंत्रित करने और सिस्टम के बाकी हिस्सों के साथ इसकी इंटरैक्शन के लिए जिम्मेदार लॉजिक विकसित करेंगे।

आप इस Logic Brick को सीधे Entity में जोड़ सकते हैं या इसे प्लेटफॉर्म Template के माध्यम से कॉन्फ़िगर कर सकते हैं, जिस तरह हमने पिछले पाठों में किया था।

चूंकि यह प्लेटफॉर्म ऐसा है जिसे आप शायद पुनः उपयोग करना चाहेंगे, इसे Template के माध्यम से कॉन्फ़िगर करना आमतौर पर एक अच्छा विकल्प होता है।

पहले, चलिए दो गुण बनाते हैं।

पहला गुण प्लेटफॉर्म Logic Brick में जोड़ा जाएगा। इसका नाम Buttons होना चाहिए, और यह एक Int गुण होगा।

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

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

दूसरा गुण Scene में सीधे बनाया जाएगा, ताकि हम इसे खेल की लॉजिक के विभिन्न भागों से आसानी से एक्सेस कर सकें।

इसके लिए, 3D View में, दृश्य के आसमान/पृष्ठभूमि पर क्लिक करें ताकि स्वयं Scene का चयन हो सके।

फिर, Properties पैनल में, आपको दिखाई देगा कि चयनित वस्तु का प्रकार Scene है, साथ ही वर्तमान दृश्य का नाम भी।

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

Scene के Properties टैब पर क्लिक करें और एक नया गुण बनाएं जिसका नाम Button Count हो।

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

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

संक्षेप में:

• Buttons प्लेटफॉर्म का हिस्सा है और यह बताता है कि कितने बटन मौजूद हैं।
• Button Count Scene का हिस्सा है और बताता है कि अब तक कितने बटन सक्रिय किए जा चुके हैं।

अब जब हमने दो गुण बना लिए हैं, एक Scene में और एक प्लेटफॉर्म Logic Brick में, चलिए प्लेटफॉर्म लॉजिक विकसित करना शुरू करते हैं।

Graph पर वापस लौटें।

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

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

पहले, Scene का उपयोग करें और उस नोड का उपयोग करें जो button टैग वाले सभी Entities की खोज करता है।

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

फिर, Size नोड का उपयोग करें ताकि उस सूची में पाए गए Entities की संख्या प्राप्त कर सकें।

यह मान दृश्य में मौजूद बटनों की कुल संख्या का प्रतिनिधित्व करता है।

अंत में, इस परिणाम को प्लेटफॉर्म के Buttons गुण में Set Buttons का उपयोग करके संग्रहीत करें।

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

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

इस चेक के लिए, हम On Update का उपयोग करेंगे, यह सुनिश्चित करते हुए कि स्थिति खेल चलने के दौरान निरंतर सत्यापित होती रहे।

पहले, Scene प्राप्त करें और इसके गुणों तक पहुँचें।

चूंकि हमने पहले Scene में Button Count गुण बनाया था, हम इसे Get Properties नोड के माध्यम से एक्सेस कर सकते हैं, जो Scene के सभी गुणों के साथ एक शब्दकोश लौटाता है।

फिर इस शब्दकोश को Get Property नोड से जोड़ें और नाम Button Count सूचित करें, ताकि यह बिल्कुल उस गुण को पुनर्प्राप्त करे जो हमने Scene में बनाया था।

डिफ़ॉल्ट रूप से, Get Property का आउटपुट प्रकार Any होता है।

चूंकि हमें इस मान की तुलना प्लेटफॉर्म के Buttons गुण से करने की आवश्यकता है, जो एक पूर्णांक संख्या है, Get Property के आउटपुट प्रकार को Int में बदलें।

फिर इस मान की तुलना प्लेटफॉर्म के Buttons गुण से करें, जो मानचित्र में उपलब्ध बटनों की कुल संख्या को संग्रहीत करता है।

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

इस क्षण में, हम चाहते क्रिया को निष्पादित कर सकते हैं।

इस उदाहरण में, हम दृश्य से प्लेटफॉर्म Entity को हटा देंगे।

बिल्कुल सही। हमारे प्लेटफॉर्म की लॉजिक अब तैयार है।

प्लेटफॉर्म पहले से ही यह पहचानने में सक्षम है कि खेल शुरू होते ही मानचित्र में कितने बटन हैं।

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

इसके साथ, प्लेटफॉर्म गतिशील रूप से यह निर्धारित कर सकता है कि कब सभी बटन सक्रिय हो गए हैं, Button Count Scene गुण में संग्रहीत मान की तुलना करके बटनों की कुल संख्या के साथ।

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

इसका अर्थ है कि तत्वों के बीच संचार पहले से ही योजना बना लिया गया है:

• प्लेटफॉर्म यह गिनता है कि कितने बटन मौजूद हैं
• प्रत्येक बटन सक्रिय होने पर Scene गुण को अपडेट करेगा
• प्लेटफॉर्म Scene गुण की जांच करता है
• जब गिनती कुल से मेल खाती है, तो प्लेटफॉर्म अपनी क्रिया निष्पादित करता है

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