Cave: शुरुआत गाइड

Back to Learn

पात्र और एनीमेशन

Lesson 13 of 19 • 25 XP

हिन्दी (Hindi)
English (original) Portuguese Francais (French) Deutsch (German) हिन्दी (Hindi) 日本語 (Japanese) Русский (Russian) 简体中文 (Simplified Chinese) Español (Spanish)

Keep your place in this quest

Log in or sign up for free to subscribe, follow lesson progress, and access more learning content.

Log In Sign Up Free

अब चलिए समझते हैं कि Cave में पात्र और एनिमेशन कैसे काम करते हैं। एक पात्र केवल एक 3D मॉडल नहीं है जो स्तर पर चल रहा है। एक असली खेल सेटअप में, यह आमतौर पर भौतिकी, आंदोलन लॉजिक, एक दृश्य मेष, एक आर्मेचर, एनिमेशन्स, और कोड या लॉजिक ब्रिक्स को मिलाता है जो यह तय करते हैं कि कौन सी एनिमेशन चलनी चाहिए।

इसे व्यावहारिक बनाने के लिए, हम Cave के स्टार्टर प्रोजेक्ट से डिफ़ॉल्ट Player टेम्पलेट का मुख्य संदर्भ के रूप में उपयोग करेंगे। अगर आप Third Person Game या Top Down Game बनाते हैं, तो Cave एक खिलाड़ी बनाता है जो पहले से ही चलता है, एक दृश्य एनिमेटेड पात्र है, और बुनियादी स्थानीयकरण एनिमेशन्स चलाता है।

image.png

यह पाठ आपको दिखाएगा कि वह सेटअप कैसे व्यवस्थित है और आप Python से एनिमेशन्स को कैसे नियंत्रित कर सकते हैं।

आप सीखेंगे:

  • स्टार्टर Player टेम्पलेट कैसे बनाया गया है।
  • क्यों दृश्य मेष एक चाइल्ड एंटिटी है, न कि रूट प्लेयर एंटिटी पर।
  • एनिमेशन कंपोनेंट क्या करता है।
  • Python से एनिमेटर कैसे प्राप्त करें (लॉजिक ब्रिक्स के लिए समान लॉजिक लागू होता है)।
  • नाम द्वारा एनिमेशन्स कैसे खेलें।
  • ब्लेंडिंग, परतें, और बोन फ़िल्टर कैसे काम करते हैं।
  • एनिमेशन कोल्बैक और सॉकेट कैसे सिस्टम में फिट होते हैं।

प्लेयर टेम्पलेट संरचना

स्टार्टर प्रोजेक्ट में, Player एक एंटिटी टेम्पलेट है। इसका मतलब है कि खिलाड़ी सेटअप पुन: प्रयोज्य है और इसे कई दृश्यों में रखा जा सकता है।

संरचना लगभग इस प्रकार है:

image.png

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

स्टार्टर दुश्मन एक बहुत समान विचार का उपयोग करता है। दुश्मन रूट एंटिटी में पात्र भौतिकी और व्यवहार है, और इसकी चाइल्ड Mesh एंटिटी में दृश्य मेष और एनिमेशन कंपोनेंट होता है।

रूट प्लेयर एंटिटी

रूट Player एंटिटी गेमप्ले पात्र का प्रतिनिधित्व करती है। इसमें सामान्यतः शामिल होते हैं:

  • एक Transform Component।
  • एक Character Component।
  • खिलाड़ी आंदोलन, UI, एनिमेशन सहायता, और अन्य गेमप्ले लॉजिक के लिए Python कंपोनेंट।
  • स्वास्थ्य या वैकल्पिक व्यवहार सेटिंग्स जैसी प्रॉपर्टीज।
  • कैमरा, UI, दृश्य मेष और सहायक ऑब्जेक्ट के लिए उपयोग किया जाने वाला चाइल्ड।

Character Component विशेष रूप से महत्वपूर्ण है क्योंकि यह पात्र-शैली की भौतिकी को संभालता है: चलना, कूदना, टकराव, ढलान, और दुनिया के खिलाफ आंदोलन। इसका मतलब है कि रूट Player मुख्य रूप से गेमप्ले और भौतिकी के लिए जिम्मेदार है।

मेष चाइल्ड एंटिटी

प्लेयर टेम्पलेट के अंदर, एक चाइल्ड एंटिटी है जिसे Mesh कहा जाता है। यह चाइल्ड सामान्यतः शामिल होती है:

  • एक Transform Component।
  • एक या अधिक Mesh Components।
  • एक Animation Component।

मेष कंपोनेंट पात्र को उसका दृश्य 3D मॉडल और सामग्री प्रदान करता है। यदि पात्र को कई सामग्रियों की आवश्यकता होती है, तो Cave इसे कई मेष कंपोनेंट्स के साथ प्रस्तुत कर सकता है, उसी मल्टीमैटेरियल नियम के अनुसार जिसे आयात पाठ में समझाया गया है।

एनिमेशन कंपोनेंट वही है जो आर्मेचर का मूल्यांकन करता है और एनिमेशन्स खेलता है।

तो, सरल तरीके से:

एंटिटी मुख्य जिम्मेदारी
Player भौतिकी, आंदोलन, गेमप्ले लॉजिक, प्रॉपर्टीज।
Player -> Mesh दृश्य मॉडल, सामग्री, आर्मेचर एनिमेशन।

यह पृथक्करण जानबूझकर किया गया है।

क्यों मेष एक चाइल्ड एंटिटी है

आप सोच सकते हैं कि मेष को सीधे रूट Player एंटिटी पर क्यों नहीं रखा गया है।

इसके पीछे कारण यह है कि भौतिकी पात्र और दृश्य एनिमेटेड पात्र अक्सर अलग-अलग ट्रांसफार्म की आवश्यकता होती है।

रूट Player ट्रांसफ़ॉर्म गेमप्ले शरीर का प्रतिनिधित्व करता है। यह वह चीज है जो दुनिया के माध्यम से चलती है, दीवारों के खिलाफ टकराती है, और Character Component को ले जाती है। चाइल्ड Mesh ट्रांसफ़ॉर्म यह दर्शाता है कि पात्र कैसे दिखता है।

यह पृथक्करण कई परिस्थितियों में उपयोगी है:

  • मेष को भौतिकता कैप्सूल से अलग आकार की आवश्यकता हो सकती है।
  • मेष को पात्र टकराव के साथ संरेखित करने के लिए एक छोटे ऑफसेट की आवश्यकता हो सकती है।
  • मेष को आंदोलन शरीर से स्वतंत्र रूप से घूमने की आवश्यकता हो सकती है।
  • मेष को मूवमेंट दिशा को सामना करना पड़ सकता है जबकि रूट एक गेमप्ले दिशा बनाए रखता है।
  • मेष को आगे की दिशा में बने रहने की आवश्यकता हो सकती है जबकि खिलाड़ी तरफ से चलता है।

उदाहरण के लिए, कल्पना कीजिए कि खिलाड़ी बाईं ओर चल रहा है। यदि आपके पास सही "बाईं ओर चलने" की एनिमेशन है, तो आप चाहेंगे कि पात्र का मेष आगे की ओर बना रहे जबकि एनिमेशन तरफ के आंदोलन को संभाले। लेकिन यदि आपके पास एक तरफ की एनिमेशन नहीं है, तो आप चाहेंगे कि मेष बाईं ओर मुड़ जाए ताकि पात्र दृश्यता से उस दिशा में चल रहा हो।

दोनों केस मान्य हैं।

उन्हें अलग-अलग ट्रांसफार्म की आवश्यकता होती है:

ट्रांसफार्म नियंत्रण
रूट Player ट्रांसफार्म भौतिक स्थिति, गेमप्ले शरीर, दुनिया के माध्यम से आंदोलन।
चाइल्ड Mesh ट्रांसफार्म दृश्य अभिविन्यास, आकार, ऑफसेट्स, एनिमेशन प्रस्तुति।

यही कारण है कि स्टार्टर खिलाड़ी और दुश्मन ने एनिमेटेड मेष को चाइल्ड एंटिटी के रूप में रखा है।

एनिमेशन कंपोनेंट क्या करता है

Animation Component मुख्य कंपोनेंट है जिसका उपयोग एन्टीटी पर कंकाली एनिमेशन्स चलाने के लिए किया जाता है।

इसकी आवश्यकता होती है:

  • एक Armature।
  • एक डिफ़ॉल्ट Animation।
  • उसी एंटिटी पर एक मान्य Mesh Component (या कई)।

आर्मेचर कंकाल को परिभाषित करता है। एनिमेशन परिभाषित करती है कि वह कंकाल समय के साथ कैसे चलता है। एनिमेशन कंपोनेंट अंतिम एनिमेटेड स्थिति का मूल्यांकन करता है और इसे दृश्य पात्र पर लागू करता है।

डिफ़ॉल्ट स्टार्टर खिलाड़ी में, Mesh चाइल्ड का उपयोग करता है:

  • Proto Mesh
  • Proto Mat
  • Proto Armature
  • p-idle डिफ़ॉल्ट एनिमेशन के रूप में (आध idle एनिमेशन)

वे स्टार्टर एसेट्स इसलिए हैं ताकि आप तुरंत एक कार्यशील एनिमेटेड पात्र की जांच कर सकें।

आर्मेचर्स, एनिमेशन्स, और रिटार्गेटिंग

  • एक Armature पात्र का कंकाल है। इसमें वह हड्डियाँ होती हैं जिनका मेष अनुसरण करता है।
  • एक Animation कंकाल में हड्डियाँ के लिए समय के साथ गति को संचित करती है।

एनिमेशन कंपोनेंट उन टुकड़ों को एक साथ जोड़ती है:

टुकड़ा अर्थ
मेष दृश्य पात्र मॉडल।
आर्मेचर पात्र के अंदर कंकाल।
एनिमेशन गति, जैसे idle, walk, run, या fall।
एनिमेशन कंपोनेंट एंटिटी पर एनिमेशन चलाने वाला कंपोनेंट।

Cave также रिटार्गेटिंग कर सकता है जब संभव हो। यदि खेल रही एनिमेशन किसी अन्य संगत आर्मेचर की है, तो एनिमेशन कंपोनेंट उस आंदोलन को वर्तमान आर्मेचर पर लागू करने के लिए रिटार्गेटिंग का उपयोग कर सकता है।

रिटार्गेटिंग उपयोगी होती है जब आप संगत पात्रों के बीच एनिमेशन्स को पुन: उपयोग करना चाहते हैं, लेकिन यह आयात किए गए रिग्स की गुणवत्ता और संगतता पर भी निर्भर करता है। यदि कोई एनिमेशन टेढ़ा, ऑफसेट, या अजीब दिखता है, तो स्रोत रिग, आयातित आर्मेचर, और रिटार्गेटिंग सेटअप की जाँच करें।

Python से एनिमेटर प्राप्त करना

अब चलिए यह अन्वेषण करना शुरू करते हैं कि हम लॉजिक के माध्यम से पात्रों को कैसे एनिमेट कर सकते हैं।

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

यहाँ बुनियादी पैटर्न है:

import cave

class PlayerAnimationExample(cave.Component):
    def start(self, scene: cave.Scene):
        self.mesh : cave.Entity = self.entity.getChild("Mesh")
        self.animator : cave.AnimationComponent = self.mesh.get("Animation")

    def update(self):
        # उदाहरण: idle एनिमेशन चलाना।
        self.animator.playByName("p-idle", blend=0.2, loop=True)

इस उदाहरण में:

  • self.entity रूट Player एंटिटी है।
  • getChild("Mesh") दृश्य चाइल्ड एंटिटी को खोजता है।
  • self.mesh.get("Animation") एनिमेशन कंपोनेंट को प्राप्त करता है।
  • इस वेरिएबल का नाम animator है, जो Cave स्क्रिप्ट्स में सामान्य नामकरण प्रथा है।
  • playByName(...) किसी एनिमेशन एसेट को नाम से खेलाता है।

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

नाम द्वारा एनिमेशन्स खेलना

आपका सबसे सामान्य विधि playByName का उपयोग होगा।

इसका बुनियादी उपयोग इस प्रकार दिखता है:

self.animator.playByName("p-walk", blend=0.2, loop=True)

अहम पैरामीटर हैं:

पैरामीटर अर्थ
anim खेलाए जाने वाली एनिमेशन एसेट का नाम।
blend कितने समय, सेकंड में, Cave को नई एनिमेशन में मिश्रण करना चाहिए।
loop क्या एनिमेशन को दोहराना चाहिए।
layer कौन सी एनिमेशन परत एनिमेशन को खेलाएगी।

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

self.animator.playByName("p-idle", blend=0.2, loop=True)
self.animator.playByName("p-walk", blend=0.2, loop=True)
self.animator.playByName("p-run", blend=0.2, loop=True)
self.animator.playByName("p-fall", blend=0.2, loop=True)

ये वही प्रकार के कॉल हैं जो डिफ़ॉल्ट खिलाड़ी और दुश्मन स्क्रिप्टों द्वारा उपयोग किए जाते हैं।

एक सरल स्थानीयकरण उदाहरण

एक सामान्य खिलाड़ी एनिमेशन सेटअप है:

  • जब पात्र खड़ा होता है तो idle खेलें।
  • जब पात्र चल रहा होता है तो चलें।
  • जब पात्र दौड़ते समय चलता है तो दौड़ें।
  • जब पात्र जमीन पर नहीं होता है तो गिरें।

यहाँ एक सरल उदाहरण है:

import cave

class SimplePlayerAnimator(cave.Component):
    def start(self, scene: cave.Scene):
        self.character : cave.CharacterComponent = self.entity.get("Character")

        self.mesh : cave.Entity = self.entity.getChild("Mesh")
        self.meshTransform : cave.TransformComponent = self.mesh.getTransform() if self.mesh else None
        self.animator      : cave.AnimationComponent = self.mesh.get("Animation") if self.mesh else None

    def update(self):
        if self.animator is None or self.character is None:
            return

        direction = self.character.getWalkDirection()
        isMoving = direction.length() > 0
        isRunning = False # इसे अपनी खुद की इनपुट या गेमप्ले स्थिति के साथ बदलें।

if self.character.onGround():
            if isMoving:
                if isRunning:
                    self.animator.playByName("p-run", blend=0.2, loop=True)
                else:
                    self.animator.playByName("p-walk", blend=0.2, loop=True)
            else:
                self.animator.playByName("p-idle", blend=0.2, loop=True)
        else:
            self.animator.playByName("p-fall", blend=0.2, loop=True)

यह उदाहरण जानबूझकर सरल है। असली स्टार्टर्स नियंत्रक इनपुट, मूवमेंट दिशा, कूदना, वैकल्पिक पॉइंट-एंड-क्लिक व्यवहार, और मेष घुमाव को संभालता है, लेकिन एनीमेशन का विचार वही है।

आंदोलन की दिशा की ओर मेष घुमाना

क्योंकि दृश्य Mesh घटक का खुद का ट्रांसफॉर्म है, आप इसे रूट Player से अलग घुमा सकते हैं।

स्टार्टर प्लेयर ऐसा करता है जब चरित्र चलता है:

if direction.length() > 0 and self.meshTransform:
    self.meshTransform.lookAtSmooth(
        self.entity.getTransform().transformDirection(-direction),
        6.0 * cave.getDeltaTime()
    )

महत्वपूर्ण विचार सटीक गणित नहीं है। महत्वपूर्ण विचार यह है कि गेमप्ले शरीर और दृश्य मेष को अलग से नियंत्रित किया जा सकता है।

यह आपको यह चुनने की अनुमति देता है कि चरित्र को कैसे सामना करना चाहिए:

  • आंदोलन दिशा की ओर मुड़ें।
  • स्ट्रेफिंग करते समय आगे की तरफ देखना जारी रखें।
  • इच्छित दिशा की ओर हरकत से घुमा।
  • विभिन्न गेमप्ले मोड के लिए विभिन्न दृश्य अभिविन्यास नियमों का उपयोग करें।

यह मुख्य कारणों में से एक है कि स्टार्टर चरित्र का एक बच्चे का Mesh घटक है।

एनीमेशन ब्लेंडिंग

एनीमेशन ब्लेंडिंग संक्रमणों को चिकना बनाता है।

बिलेंडिंग के बिना, एक एनीमेशन से दूसरे में स्विच करना तुरंत हो सकता है। ब्लेंडिंग के साथ, Cave एक ही स्तर पर एनीमेशन के बीच धीरे-धीरे संक्रमण कर सकता है।

उदाहरण:

# इससे:
self.animator.playByName("p-idle", blend=0.2, loop=True)

# इस पर:
self.animator.playByName("p-walk", blend=0.2, loop=True)

यहाँ, blend=0.2 का मतलब है कि Cave नए एनीमेशन में 0.2 सेकंड के भीतर मिश्रण करेगा।

यह विशेष रूप से पात्रों के लिए महत्वपूर्ण है। एक खिलाड़ी प्रोटोटाइप में भी कठोर एनीमेशन पॉप्स को बहुत आसानी से देख सकता है।

अच्छे शुरुआती मिश्रण मूल्य आमतौर पर छोटे होते हैं:

  • 0.1 बहुत तेज़ संक्रमणों के लिए।
  • 0.2 सामान्य लोकमोशन संक्रमणों के लिए।
  • 0.4 या अधिक धीमे, भारी संक्रमणों के लिए।

आपको इसे अनुभव के अनुसार ट्यून करना चाहिए।

एनीमेशन स्तर

Cave एकाधिक एनीमेशन स्तरों का समर्थन करता है। प्रत्येक स्तर अपने एनीमेशन को चला सकता है, और ऊपरी स्तर निम्न स्तरों के शीर्ष पर stacked हो सकते हैं। आप जिस भी स्तर पर चाहें एनीमेशन चला सकते हैं।

डिफ़ॉल्ट लोकमोशन एनीमेशन आमतौर पर स्तर 0 पर चलता है।

उदाहरण:

self.animator.playByName("p-walk", blend=0.2, layer=0, loop=True)

यदि आपके पास एक अपर-शरीर क्रिया एनीमेशन है, जैसे कि हमले, लक्ष्य या रीलोड, तो आप इसे दूसरे स्तर पर चला सकते हैं:

self.animator.playByName("Attack", blend=0.1, layer=1, loop=False)

विचार यह है:

स्तर सामान्य उद्देश्य
स्तर 0 पूर्ण-शरीर लोकमोशन, जैसे कि स्थिर, चलना, भागना, कूदना, गिरना।
स्तर 1 अपर-शरीर क्रियाएँ, जैसे कि हमला, लक्ष्य, रीलोड, हथियार पकड़ना।

यह चरित्र को चलने की अनुमति देता है जबकि एक अन्य स्तर पर एक क्रिया जोड़ी जाती है।

स्तर वजन

प्रत्येक स्तर का एक वजन होता है, जो नियंत्रित करता है कि उस स्तर का कितना प्रभाव है।

आप इसे Python से बदल सकते हैं:

self.animator.setLayerWeight(1, 1.0)

आप इसे पढ़ भी सकते हैं:

weight = self.animator.getLayerWeight(1)

1.0 का वजन मतलब है कि स्तर पूरी तरह से सक्रिय है। 0.0 का वजन मतलब है कि इसका कोई दृश्य प्रभाव नहीं है।

स्तर वजन तब उपयोगी हैं जब आप किसी क्रिया स्तर को अंदर या बाहर धुंधला करना चाहते हैं, जैसे कि धीरे-धीरे एक हथियार उठाना, लक्ष्य बनाना, या एक विशेष स्थिति में मिश्रण करना।

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

हड्डी फ़िल्टर

हड्डी फ़िल्टर नियंत्रण करते हैं कि एक स्तर द्वारा किन हड्डियों पर प्रभाव पड़ता है और प्रत्येक हड्डी को कितना प्रभाव मिलता है।

यह अपर-शरीर एनीमेशन को संभव बनाता है।

उदाहरण के लिए, आप चाहते होंगे:

  • स्तर 0 पूरे शरीर को नियंत्रित करता है।
  • स्तर 1 केवल रीढ़, हाथ, हाथ, और हथियार हड्डियों को नियंत्रित करता है।

Python में, आप एक स्तर के लिए एक फ़िल्टर बना सकते हैं और एक हड्डी और उसके बच्चों को प्रभाव असाइन कर सकते हैं:

def setupUpperBodyLayer(self):
    armature = self.animator.armature.get()
    spine = armature.getBone("mixamorig:Spine")

    upperBody = self.animator.createLayerFilter(1)
    upperBody.defaultBlend = 0.0
    upperBody.setToBone(spine, 1.0, recursive=True)

इस उदाहरण में:

  • defaultBlend = 0.0 का मतलब है कि स्तर डिफ़ॉल्ट रूप से कोई हड्डियों पर प्रभाव नहीं डालता है।
  • setToBone(spine, 1.0, recursive=True) का मतलब है कि रीढ़ और इसके बच्चे पूरी तरह से प्रभावित होते हैं।
  • स्तर 1 अब अपर-शरीर एनीमेशन के लिए उपयोग किया जा सकता है।

आपके हड्डी नाम उस आर्मेचर पर निर्भर करते हैं जिसे आपने आयात किया। हमेशा अपने आर्मेचर की जांच करें और अपने चरित्र के लिए सही हड्डी नामों का उपयोग करें।

व्यावहारिक स्तर उदाहरण

कल्पना करें कि एक तीसरे व्यक्ति का चरित्र चल सकता है और एक ही समय में हमला कर सकता है।

एक संभावित सेटअप है:

स्तर यह क्या संभालता है
स्तर 0 स्थिर, चलना, भागना, गिरना।
स्तर 1 अपर-शरीर हमला।

कोड इस तरह दिख सकता है:

import cave

class CombatAnimator(cave.Component):
    def start(self, scene: cave.Scene):
        self.mesh = self.entity.getChild("Mesh")
        self.animator : cave.AnimationComponent = self.mesh.get("Animation") if self.mesh else None

        if self.animator:
            armature = self.animator.armature.get()
            spine = armature.getBone("mixamorig:Spine")

            upperBody = self.animator.createLayerFilter(1)
            upperBody.defaultBlend = 0.0
            upperBody.setToBone(spine, 1.0, recursive=True)
            self.animator.setLayerWeight(1, 1.0)

    def playWalk(self):
        self.animator.playByName("p-walk", blend=0.2, layer=0, loop=True)

    def playAttack(self):
        self.animator.playByName("Attack", blend=0.1, layer=1, loop=False)

यह उदाहरण मानता है कि आपके पास Attack नामक एक एनीमेशन संपत्ति है। यदि आपके प्रोजेक्ट का एनीमेशन नाम अलग है, तो उस नाम का उपयोग करें।

महत्वपूर्ण विचार यह है कि लोकमोशन स्तर 0 पर रहता है, जबकि हमला स्तर 1 पर खेलता है और केवल फ़िल्टर की गई हड्डियों को प्रभावित करता है।

एनीमेशन कॉलबैक

एनीमेशन विशिष्ट समय पर Python कोड चला सकते हैं।

Cave के पास कॉलबैक का समर्थन करता है जैसे:

  • एनीमेशन शुरू होने पर।
  • एनीमेशन समाप्त होने पर।
  • एक विशिष्ट एनीमेशन फ्रेम पर।

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

उदाहरण:

  • एक फुटस्टेप ध्वनि चलाना।
  • एक कदम पर धूल बिखेरना।
  • एक हमले के फ्रेम पर नुकसान लगाना।
  • एक हथियार ट्रेल शुरू करना।
  • एक कण प्रभाव को ट्रिगर करना।
  • लॉजिक को सूचित करना कि एक एनीमेशन समाप्त हो गया।

एनीमेशन अक्सर सटीक समय को कोड की तुलना में बेहतर जानते हैं। यदि एक तलवार को केवल तभी नुकसान पहुँचाना चाहिए जब झूल target क्षेत्र में पहुँच जाए, तो एक एनीमेशन कॉलबैक उस गेमप्ले क्षण को सही फ्रेम पर रख सकता है।

फुटस्टेप कॉलबैक उदाहरण

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

विचार सरल है:

  1. एनीमेशन जानता है कि फुट जमीन को छूता है।
  2. कॉलबैक उस फ्रेम पर रखा गया है।
  3. कॉलबैक एक ध्वनि चलाता है या एक छोटा प्रभाव उत्पन्न करता है।

एक बहुत छोटा फुटस्टेप कॉलबैक इस तरह दिख सकता है:

cave.playSound("Footstep Grass", volume=0.5)

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

पुन: प्रयोज्य एनीमेशन कॉलबैक

कॉलबैक एनीमेशन संपत्ति से संबंधित होते हैं।

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

यह कॉलबैक को पुन: प्रयोज्य बनाता है। उदाहरण के लिए, वही चलने वाली एनीमेशन हर चरित्र के लिए फुटस्टेप ध्वनियाँ उत्पन्न कर सकता है जो इसे खेलते हैं, बशर्ते कॉलबैक कोड सही ढंग से स्वामित्व वाले घटक का उपयोग करता है।

एनीमेशन समय संग्रहीत करता है। घटक संदर्भ प्रदान करता है।

उन्नत पोस कॉलबैक

Cave Python के माध्यम से पोस्ट-संविधान कॉलबैक का भी समर्थन करता है। ये एनीमेशन घटक के आर्मेचर पोस का मूल्यांकन करने के बाद होते हैं।

यह एक उन्नत सुविधा है, लेकिन इसका उपयोग किया जा सकता है:

  • उल्टा अपक्षिका।
  • सिर लक्ष्य बनाना।
  • हथियार लक्ष्य बनाना।
  • फुट प्लेसमेंट।
  • अंतिम पोस समायोजन।

स्टार्टर Player Toolkit में इस अवधारणा का उपयोग करने वाला एक फ़ुट आईके उदाहरण शामिल है। यह Mesh बच्चे को प्राप्त करता है, Animation घटक प्राप्त करता है, फिर इसमें पंजीकृत करता है:

self.animator.addPostEvaluationCallback(self.postEvaluation)

आपको तुरंत आईके सिस्टम लिखने की आवश्यकता नहीं है, लेकिन यह जानना उपयोगी है कि Cave Python को सामान्य एनीमेशन प्लेबैक के बाद अंतिम पोस को समायोजित करने की अनुमति देता है।

एनीमेशन सॉकेट कंपोनेंट

Animation Socket Component एक बच्चे के घटक को एक माता-पिता एनिमेटेड घटक से एक हड्डी का पालन करने देता है।

बच्चे का घटक एक ऐसे माता-पिता के तहत होना चाहिए जिसमें एक एनीमेशन कंपोनेंट हो। तब सॉकेट उस हड्डी का चुनाव कर सकता है और आवश्यकता होने पर उस हड्डी से स्थिति, घुमाव, और वैकल्पिक रूप से स्केल की नकल कर सकता है।

सॉकेट का उपयोग एनिमेटेड चरित्रों से चीजें जोड़ने के लिए किया जाता है:

  • हाथ में तलवार।
  • हाथ में बंदूक।
  • हाथ पर ढाल।
  • सिर पर हेलमेट।
  • रीढ़ की हड्डी पर बैकपैक।
  • हाथ से जुड़ा प्रॉप।

उदाहरण के लिए, यदि कोई चरित्र तलवार पकड़ता है, तो तलवार एक बच्चा एंटिटी हो सकती है जिसमें एक Animation Socket Component हो जो हाथ की हड्डी का अनुसरण करता है। जब चरित्र हमला करता है, दौड़ता है, या ठहरता है, तो तलवार सही एनिमेटेड स्थिति पर अटकी रहती है।

आपको क्या याद रखना चाहिए

  • प्रारंभिक खिलाड़ी एक टेम्पलेट है जिसमें एक मूल Player एंटिटी और एक बच्चा Mesh एंटिटी होती है।
  • मूल Player आमतौर पर भौतिकी, आंदोलन, गुण और गेमप्ले लॉजिक को संभालता है।
  • बच्चा Mesh आमतौर पर दृश्य मॉडल, सामग्री, आर्मेचर और Animation Component को संभालता है।
  • यह विभाजन भौतिक शरीर और दृश्य चरित्र को अलग ट्रांसफॉर्म देता है।
  • Animation Component कंकाली एनिमेशन को आर्मेचर और एनिमेशन संपत्तियों का उपयोग करके चलाता है।
  • Python में, Animation Component को आमतौर पर animator कहा जाता है।
  • playByName नाम से एक एनिमेशन संपत्ति को चलाता है और मिश्रण, लूपिंग, और परतों का समर्थन करता है।
  • परतें कई एनिमेशनों को एक साथ स्टैक करने देती हैं।
  • बोन फ़िल्टर एक परत को केवल कंकाल के एक भाग को प्रभावित करने में सक्षम बनाते हैं।
  • एनिमेशन कॉलबैक एनिमेशन समय को गेमप्ले घटनाओं से जोड़ते हैं।
  • एनिमेशन सॉकेट प्रॉप्स को एनिमेटेड हड्डियों से जोड़ते हैं।

जब आप प्रारंभिक Player या Enemy टेम्पलेट की जांच करते हैं, तो इस संरचना का उपयोग मानचित्र के रूप में करें: गेमप्ले के लिए मूल एंटिटी, दृश्य और एनिमेशन के लिए बच्चा Mesh एंटिटी।

Next: लॉजिक्स ब्रिक्स की मूल बातें