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

इस पाठ में, हम अपने खिलाड़ी लॉजिक में एनीमेशन को एकीकृत करना शुरू करेंगे।

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

मुख्य विचार सरल है: हम इस पर निर्भर करेंगे कि चरित्र की वर्तमान स्थिति क्या है ताकि यह निर्णय लिया जा सके कि कौन सा एनीमेशन चलाया जाना चाहिए।

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

• यदि खिलाड़ी जमीन पर है और चल नहीं रहा है, तो आँखें बंद एनीमेशन चलाएँ।
• यदि खिलाड़ी जमीन पर है और चल रहा है, तो चलने का एनीमेशन चलाएँ।
• यदि खिलाड़ी दौड़ रहा है, तो दौड़ने का एनीमेशन चलाएँ।
• यदि खिलाड़ी जमीन पर नहीं है, तो गिरने का एनीमेशन चलाएँ।

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

1. एनीमेशन निष्पादन लॉजिक बनाना

अब जब हमने घटनाओं को बनाने और व्यवस्थित करने का तरीका सीख लिया है, चलिए एक नई घटना बनाते हैं जो एनीमेशन लॉजिक ब्लॉक को एनीमेशन अपडेट करें कहा जाएगा।

यह घटना खिलाड़ी की एनीमेशन स्थिति को अपडेट करने के लिए जिम्मेदार होगी।

पहली चीज़ जो हम करेंगे, वह इस घटना को एक यदि नोड से कनेक्ट करना है जो जांचता है कि क्या चरित्र वर्तमान में जमीन पर है या नहीं। यह जानकारी यह तय करने के लिए उपयोग की जाएगी कि कौन सा एनीमेशन चलाया जाना चाहिए।

उदाहरण के लिए, जब खिलाड़ी जमीन पर होता है, तो हम आँखें बंद, चलने, या दौड़ने के एनीमेशन चला सकते हैं। जब खिलाड़ी जमीन पर नहीं होता है, तो हम इसके बजाय गिरने का एनीमेशन चला सकते हैं।

अगला, हमें एनिमेशन कंपोनेंट तक पहुँचने की आवश्यकता है, जो चरित्र के एनीमेशन को प्रबंधन और चलाने के लिए जिम्मेदार है।

इसके लिए, हम पहले एंटिटी प्राप्त करेंगे, फिर चाइल्ड नोड का उपयोग करके उसे मेहस नामक चाइल्ड ऑब्जेक्ट का प्राप्त करेंगे, जो हमारे खिलाड़ी का मेष ऑब्जेक्ट है। इस चाइल्ड एंटिटी से, हम एनिमेशन कंपोनेंट तक पहुँच सकते हैं।

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

इसके लिए, उन नोड्स का चयन करें, राइट-क्लिक करें, और चयन को फ़ंक्शन में प्रोमोट करें चुनें।

यह एक फ़ंक्शन बनाएगा जो इस लॉजिक को समाहित करेगा, जिससे ग्राफ अधिक साफ और समझने में आसान हो जाएगा। यह हमें लॉजिक ब्रिक्स के अन्य भागों में बिना एक ही नोड्स को फिर से बनाने के इस प्रवाह का पुन: उपयोग करने की अनुमति भी देगा।

आइए इस फ़ंक्शन का नाम एनीमेशन चलाएँ रखें।

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

अब एनीमेशन चलाएँ फ़ंक्शन को संपादित करने के लिए डबल-क्लिक करें।

फिर फ़ंक्शन इनपुट नोड पर राइट-क्लिक करके दो नए इनपुट पिन जोड़ें।

पहला इनपुट होगा:

• एनीमेशन, प्रकार स्ट्रिंग।

इस इनपुट का उपयोग उस एनीमेशन का नाम सूचित करने के लिए किया जाएगा जो चलाया जाना चाहिए।

दूसरा इनपुट होगा:

• ब्लेंड, प्रकार फ्लोट।

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

ये पैरामीटर फ़ंक्शन को अधिक लचीला बनाते हैं।

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

गेट एनिमेशन कंपोनेंट के आउटपुट से, प्ले बाय नाम नोड जोड़ें।

यह नोड उसके नाम के आधार पर एक एनीमेशन चलाने के लिए जिम्मेदार है।

फिर फंक्शन इनपुट नोड में बनाए गए एनीमेशन और ब्लेंड पैरामीटर को प्ले बाय नाम नोड के संबंधित फ़ील्ड से कनेक्ट करें।

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

प्ले बाय नाम नोड में लूप विकल्प को सक्षम करना न भूलें।

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

अंत में, प्ले बाय नाम नोड के आउटपुट फ्लो को फंक्शन आउटपुट्स से कनेक्ट करें, जिससे एनीमेशन चलाएँ फ़ंक्शन का निष्पादन समाप्त हो जाएगा।

अब अपने चरित्र के एनीमेशनों को चलाना बहुत आसान है।

खिलाड़ी के जमीन पर या नहीं होने की स्थिति की जांच करने वाले यदि नोड पर वापस जाएँ, और एनीमेशन चलाएँ फ़ंक्शन का उपयोग करें।

जब स्थिति सत्य है, जिसका अर्थ है कि खिलाड़ी जमीन पर है, तो फ़ंक्शन को कॉल करें, और "p-idle" एनीमेशन पैरामीटर पास करें। यह एनीमेशन तब चलता है जब चरित्र स्थिर रहता है।

जब स्थिति झूठी होती है, जिसका अर्थ है कि खिलाड़ी जमीन पर नहीं है, तो फ़ंक्शन को कॉल करें, और "p-fall" पास करें। यह एनीमेशन तब होता है जब चरित्र हवा में होता है।

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

अब हमें केवल मूव खिलाड़ी इवेंट के प्रवाह में एनीमेशन अपडेट करें घटना को कॉल करना है।

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

इसके साथ, खिलाड़ी अब p-idle और p-fall के बीच अपने वर्तमान स्थिति के आधार पर स्विच कर सकेगा। जब खिलाड़ी जमीन पर है, तो यह आँखें बंद एनीमेशन चलाएगा। जब खिलाड़ी हवा में है, तो यह गिरने का एनीमेशन चलाएगा।

सही। अब चलिए खिलाड़ी के एनीमेशन लॉजिक को गति एनीमेशनों को जोड़कर विकसित करना जारी रखते हैं।

इसके लिए, हलचल दिशा प्राप्त करें और लेंग्थ नोड का उपयोग करके गति वेक्टर की तीव्रता को मापें।

गति वेक्टर की लंबाई हमें बताती है कि क्या चरित्र चल रहा है या नहीं।

फिर एक यदि नोड जोड़ें ताकि यह जांच सके कि यह मान 0 से बड़ा है या नहीं।

यदि परिणाम सत्य है, तो इसका अर्थ है कि चरित्र चल रहा है, इसलिए हम चलने के एनीमेशन p-walk को चला सकते हैं।

यदि परिणाम झूठा है, तो इसका अर्थ है कि चरित्र चल नहीं रहा है, इसलिए हमें आँखें बंद एनीमेशन p-idle चलाना चाहिए।

इससे खिलाड़ी अपने चलने के आधार पर स्थिर या चलने के बीच स्वचालित रूप से स्विच कर सकेगा।

अब हमारे चरित्र के गति एनीमेशन व्यवहार को पूरी करने के लिए दो और विवरण हैं:

पहला, जब खिलाड़ी दौड़ रहा हो, तो दौड़ने का एनीमेशन चलाना।

दूसरा, खिलाड़ी को उस दिशा में देखना चाहिए जिसमें वह चल रहा है।

चलने और दौड़ने के एनीमेशन को नियंत्रित करने के लिए, उस जांच के ठीक बाद एक अनुक्रम नोड जोड़ें जो यह सत्यापित करता है कि क्या खिलाड़ी चल रहा है।

फिर क्या दौड़ना संपत्ति प्राप्त करें और उसके मान की जांच करने के लिए एक यदि नोड का उपयोग करें।

यदि क्या दौड़ना सत्य है, तो दौड़ने का एनीमेशन चलाएँ।

यदि क्या दौड़ना झूठा है, तो चलने के एनीमेशन को चलाएँ।

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

हमने अभी जो अनुक्रम जोड़ा है, उसके दूसरे फिर आउटपुट पर स्मूद देखने नोड का उपयोग करें।

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

हमें गेट हलचल दिशा मूल्य को -1 से गुणा करने की आवश्यकता है इससे पहले कि हम इसे स्मूद देखने पर भेजें।

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

उसके बाद, पहले से ही गुणा किये गए दिशा को स्मूद देखने नोड से कनेक्ट करें।

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

इसके लिए, एंटिटी तक पहुँचें, फिर खिलाड़ी मेहस प्राप्त करें, और गेट ट्रांसफर नोड का उपयोग करें।

यह ट्रांसफर स्मूद देखने से कनेक्ट होना चाहिए, यह सुनिश्चित करते हुए कि घुमाव सही वस्तु पर लागू हो, जो चरित्र का दृश्यमान मेष है।

इस समय, खिलाड़ी के एनीमेशन लॉजिक पहले से ही अधिक पूर्ण हैं।

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