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

इस पाठ में, हम अपने Player के लिए बुनियादी गति तर्क विकसित करना जारी रखेंगे।

Cave Engine के Logic Bricks का उपयोग करते हुए, हम उस तर्क को बनाएंगे जो पात्र को चलाने और दौड़ाने के लिए जिम्मेदार है। इस प्रक्रिया में, आप जानेंगे कि खिलाड़ी के इनपुट को कैसे कैद करना है, उस इनपुट को गति दिशा में कैसे बदलना है, गति की गति को नियंत्रित करना है, और दृश्य तर्क को संगठित रखना है।

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

1. Adding Sequence

अपने Player के लिए गति तर्क विकसित करते रहने के लिए, हम Sequence नोड का उपयोग कैसे करना है यह सीखेंगे।

Sequence नोड आपको एक ही इनपुट से कई Flow आउटपुट बनाने की अनुमति देता है। यह उपयोगी है क्योंकि कई गेमप्ले सिस्टम को एक ही घटना से एक से अधिक तर्क का पालन करने की आवश्यकता होती है।

उदाहरण के लिए, हमारा On Update घटना को हर फ्रेम में कूद तर्क की जांच करने की आवश्यकता है, लेकिन इसे हर फ्रेम में गति तर्क की भी जांच करने की आवश्यकता होगी। एक बड़े और भ्रमित करने वाली श्रृंखला में सब कुछ बनाने के बजाय, हम Sequence का उपयोग करके प्रवाह को कई संगठित शाखाओं में विभाजित कर सकते हैं।

इस तरह, वही On Update घटना हर फ्रेम में विभिन्न तर्क ब्लॉकों को साफ और अधिक नियंत्रित तरीके से निष्पादित कर सकती है।

2. Creating the Movement Logic

खिलाड़ी की गति बनाने के लिए, हम पहले Events नोड जोड़ेंगे और फिर Active नोड।

Active नोड यह जांचता है कि क्या कोई कुंजी वर्तमान में दबाकर रखी गई है। यह केवल एक बार दबाए जाने की जांच करने से भिन्न है। गति के लिए, हम आमतौर पर यह जानना चाहते हैं कि क्या खिलाड़ी कुंजी को लगातार दबाकर रखता है, क्योंकि पात्र को कुंजी के सक्रिय रहते हुए आगे बढ़ना चाहिए।

हम यह सभी गति कुंजियों के लिए करेंगे:

• W आगे बढ़ाने के लिए
• S पीछे बढ़ाने के लिए
• A बाईं ओर बढ़ाने के लिए
• D दाईं ओर बढ़ाने के लिए

Active नोड का आउटपुट एक Bool मान है। एक बूलियन चर केवल दो स्थितियाँ रख सकता है: True या False।

जब हम इस बूलियन मान को Float में Bool To Float नोड का उपयोग करके परिवर्तित करते हैं, तो हमें मिलते हैं:

• 1 जब मान True हो
• 0 जब मान False हो

यह हमें कीबोर्ड स्थिति का उपयोग गणितीय ऑपरेशन में करने की अनुमति देता है।

उदाहरण के लिए, हम S के मान को W के मान से घटाकर आगे/पीछे की गति की गणना कर सकते हैं। हम A के मान को D के मान से घटाकर बाईं/दाईं की गति की गणना भी कर सकते हैं।

यह काम करता है क्योंकि प्रत्येक कुंजी या तो 0 या 1 लौटाती है।

उदाहरण के लिए, आगे और पीछे की गति के लिए:

• यदि W दबा है और S नहीं दबा है, तो परिणाम है 1 - 0 = 1, इसलिए खिलाड़ी आगे बढ़ता है।
• यदि S दबा है और W नहीं दबा है, तो परिणाम है 0 - 1 = -1, इसलिए खिलाड़ी पीछे बढ़ता है।
• यदि कोई भी कुंजी नहीं दबाई गई है, तो परिणाम है 0 - 0 = 0, इसलिए उस अक्ष पर कोई गति नहीं है।
• यदि दोनों कुंजी दबाई गई हैं, तो परिणाम है 1 - 1 = 0, इसलिए वे एक-दूसरे को रद्द कर देते हैं।

इन परिणामों के साथ, हम एक Make Vector 3 नोड जोड़ते हैं और गणना की गई मानों को X और Z ध्रुवों से जोड़ते हैं, जो गति की दिशा को परिभाषित करने के लिए जिम्मेदार होंगे।

अब Sequence नोड के पहले Then आउटपुट को इस गति तर्क के प्रवाह में जोड़ें, जबकि अन्य Then आउटपुट पिछले पाठ में बनाए गए कूद तर्क के लिए उपयोग किया जा सकता है।

अंत में, Entity प्राप्त करें, उसके Character Component तक पहुँचें, और Set Walk Direction नोड का उपयोग करें। Make Vector 3 द्वारा बनाए गए वेक्टर को दिशा पैरामीटर से कनेक्ट करें, ताकि चरित्र घटक को पता चल सके कि खिलाड़ी को कहाँ बढ़ना चाहिए।

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

सीधे Set Walk Direction में गति दिशा को परिभाषित करने के बजाय, हम पहले गति दिशा को एक संपत्ति में संग्रहीत करेंगे। यह हमें और अधिक नियंत्रण देता है क्योंकि हम इस दिशा को चरित्र में लागू करने से पहले संशोधित करने में सक्षम होंगे।

Properties टैब खोलें, एक नई संपत्ति बनाएँ, उसके प्रकार को Vector3 में बदलें, और इसे Move Dir का नाम दें।

यह संपत्ति खिलाड़ी की गति दिशा को संग्रहीत करने के लिए उपयोग की जाएगी और तर्क में अगली समायोजनों के आधार के रूप में कार्य करेगी।

संपत्ति के बगल में प्रदर्शित गियर आइकन पर क्लिक करें और इसके प्रकार को बदलने के लिए Change Type चुनें।

फिर Vector3 चुनें।

अब अपने Logic Bricks के Graph पर वापस जाएँ और हम केवल हाल ही में बनाए गए Move Dir संपत्ति को सेट करें।

Make Vector 3 नोड के आउटपुट को Move Dir संपत्ति के मान से कनेक्ट करें।

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

अब जबकि हम चरित्र की गति दिशा को Move Dir संपत्ति में संग्रहीत कर रहे हैं, आइए हम दो और संपत्तियाँ बनाएँ जिनका प्रकार Float हो:

• Walk Speed
• Run Speed

ये संपत्तियाँ प्रत्येक गति स्थिति में खिलाड़ी की गति को परिभाषित करेंगी।

यहाँ संपत्तियाँ उपयोग करना एक अच्छा अभ्यास है क्योंकि यह बाद में गति को समायोजित करना आसान बनाता है। ग्राफ के अंदर हार्डकोडेड मूल्यों की खोज करने के बजाय, आप बस Entity का चयन कर सकते हैं और गुणों के टैब से चलाने और दौड़ने की गति को सीधे समायोजित कर सकते हैं।

अब एक और संपत्ति बनाएँ, इस बार प्रकार Bool के साथ, इसे Is Running कहें।

यह संपत्ति चरित्र की दौड़ने की स्थिति को संग्रहीत करेगी। यह लॉजिक को बताएगा कि खिलाड़ी वर्तमान में दौड़ रहा है या नहीं, जिससे हमें Walk Speed और Run Speed के मूल्यों के बीच चयन करने की अनुमति मिलेगी।

अब एक Active नोड जोड़ें यह जांचने के लिए कि क्या Shift कुंजी दबाकर रखी गई है।

फिर इस स्थिति के आधार पर संपत्ति को परिभाषित करने के लिए Set Is Running का उपयोग करें। जब Shift सक्रिय होता है, Is Running को True पर सेट किया जाना चाहिए, जिससे यह इंगित होता है कि चरित्र दौड़ रहा है।

अब हम Walk Direction को Move Dir संपत्ति में संग्रहीत दिशा का उपयोग करके परिभाषित करेंगे, जबकि प्रत्येक गति स्थिति के लिए सही गति लागू करेंगे।

इसके लिए, एक If नोड जोड़ें जो Is Running संपत्ति की जाँच करती है कि वह True या False है।

यदि परिणाम True है, तो Move Dir का मान प्राप्त करें और इसे Run Speed संपत्ति से गुणा करें।

यदि परिणाम False है, तो Move Dir का मान प्राप्त करें और इसे Walk Speed संपत्ति से गुणा करें।

अंत में, इस गुणन के परिणाम को Set Walk Direction नोड से कनेक्ट करें।

इस तरह, गति दिशा वही रहती है, लेकिन उसकी तीव्रता इस पर निर्भर करती है कि खिलाड़ी चल रहा है या दौड़ रहा है।

अब हमें एक छोटी समस्या का समाधान करने की आवश्यकता है।

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

उदाहरण के लिए, केवल आगे बढ़ने से इस तरह की दिशा बनती है:

(0, 0, 1)

लेकिन एक ही समय में आगे और दाईं ओर बढ़ने से ऐसा कुछ बनता है:

(1, 0, 1)

वह विकर्ण वेक्टर एकल-अक्ष वेक्टर से लंबा होता है, जिससे पात्र विकर्ण दिशा में तेजी से बढ़ता है।

इस व्यवहार को सही करने के लिए, हम दिशा वेक्टर को Move Dir संपत्ति में संग्रहीत करने से पहले सामान्य करेंगे।

पहले, Make Vector 3 द्वारा बनाए गए वेक्टर की Length प्राप्त करें।

फिर If नोड जोड़ें ताकि यह जाँचे कि क्या यह मान 0 से बड़ा है।

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

यदि स्थिति सत्य है, तो Normalized नोड का उपयोग करके वेक्टर का सामान्यीकृत संस्करण प्राप्त करें।

अन्यथा, मूल वेक्टर का उपयोग करें।

अंत में, परिणाम को Move Dir की Set Property नोड से कनेक्ट करें।

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

3. Using Events

Logic Bricks के अंदर हमारे तर्क के प्रवाह को संरचना करने के अधिक संगठित तरीके हैं।

टिप्पणियों और Sequence नोड के अलावा, हम Events का उपयोग करके प्रणाली को अधिक साफ और समझने में आसान बना सकते हैं।

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

अब चलिए एक नया इवेंट बनाते हैं जिसे Move Player कहा जाता है।

फिर इस इवेंट को खिलाड़ी की गति तर्क ब्लॉक के प्रवाह से कनेक्ट करें।

इससे, पूरे गति तर्क को On Update के सीधे साथ नहीं जोड़ा जाएगा, लेकिन हम बस On Update अनुक्रम के भीतर Move Player इवेंट को कॉल कर सकते हैं।

इससे प्रवाह साफ, अधिक मॉड्यूलर, और समझने में आसान होता है, विशेष रूप से जैसे-जैसे परियोजना का तर्क अधिक जटिल हो जाता है।

इस बिंदु पर, खिलाड़ी के पास Logic Bricks के साथ बना एक बुनियादी गति प्रणाली है।

लॉजिक अब मूवमेंट कीज़ की जांच करता है, मूवमेंट दिशा की गणना करता है, तेज तिरछे मूवमेंट से बचने के लिए दिशा को सामान्य करता है, इसे Move Dir संपत्ति में संग्रहीत करता है, जांचता है कि क्या प्लेयर दौड़ रहा है, सही गति लागू करता है, और अंततः परिणाम को Character Component के माध्यम से Set Walk Direction पर भेजता है।