Cave: शुरूआती मार्गदर्शिका

पिछले पाठ में, आपने सीखा कि Python गेमप्ले के दौरान Entities को कैसे नियंत्रित कर सकता है। लेकिन Cave में Python केवल चल रहे गेम तक सीमित नहीं है। आप इसे Editor Tools बनाने के लिए भी इस्तेमाल कर सकते हैं जो आपके खेल को तेजी से बनाने में मदद करते हैं।

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

इस पाठ में आप सीखेंगे:

• गेमप्ले स्क्रिप्ट्स और एडिटर स्क्रिप्ट्स में क्या अंतर है।
• एक एडिटर टूल का उपयोग किस लिए किया जा सकता है।
• एक एडिटर टैब टूल की संरचना कैसी होती है।
• #editoronly क्यों महत्व रखता है।
• कब एक कस्टम टूल बनाना उचित होता है।

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

Gameplay Scripts vs Editor Tools

संक्षेप में:

• Gameplay Scripts खेल के चलते समय चलते हैं।
• Editor Tools संपादक के अंदर चलते हैं ताकि आप प्रोजेक्ट पर काम कर सकें।

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

क्यों Editor Tools उपयोगी हैं

शुरुआत में, कस्टम टूल्स केवल बड़ी टीमों के लिए लग सकते हैं।

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

एडिटर टूल्स निम्न में मदद कर सकते हैं:

• समूह में Entities रखना।
• जरूरी Components के अभाव की जांच करना।
• आम सीन सेटअप बनाना।
• डिबग जानकारी प्रिंट करना।
• Play Mode में जाए बिना मानों का परीक्षण करना।
• डिज़ाइनर्स को गेमप्ले डेटा समायोजित करने में मदद करना।

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

Editor-Only Scripts

एडिटर स्क्रिप्ट्स आमतौर पर इस पंक्ति से शुरू होते हैं:

#editoronly

यह Cave को बताता है कि यह स्क्रिप्ट संपादक में उपयोग के लिए है।

यह महत्वपूर्ण है क्योंकि एडिटर टूल्स ऐसे APIs या व्यवहार का उपयोग कर सकते हैं जो केवल संपादक के अंदर अर्थपूर्ण होते हैं। आप आमतौर पर नहीं चाहते कि लेवल डिज़ाइन हेल्पर या डिबग पैनल आपके अंतिम गेम रनटाइम का हिस्सा हो।

यह Cave को यह भी बताने में मदद करता है कि गेम स्टार्टअप में कौन-कौन सी स्क्रिप्ट्स चलानी हैं और किन्हें अनदेखा करना है। डिफ़ॉल्ट रूप से, Cave हर स्क्रिप्ट चलाता है, इसलिए यदि आप चाहते हैं कि कोई स्क्रिप्ट अनदेखी हो, तो उसे पहली लाइन के रूप में यह टिप्पणी शामिल करनी चाहिए।

इसलिए, यदि आप ऐसी स्क्रिप्ट बना रहे हैं जो सिर्फ Cave Editor के अंदर काम करने में मदद करती है, तो उसे editor-only बनाएं।

Editor Tab Tools

एक सामान्य तरीका टूल बनाने का है एक Editor Tab के साथ।

एक एडिटर टैब Cave Editor के अंदर दिखाई देने वाला एक कस्टम पैनल होता है। इसमें draw() मेथड होता है, और जब टैब दिख रहा होता है, तो Cave उस मेथड को कॉल करता है ताकि टूल बटन, टेक्स्ट, प्रॉपर्टीज़, और अन्य कंट्रोल्स को ड्रॉ कर सके।

एक बहुत ही छोटा एडिटर टैब इस प्रकार दिखता है:

#editoronly
import cave

class ExampleTab(cave.ui.DebugTab):
    def __init__(self):
        super().__init__()
        self.counter = 0

    def draw(self):
        cave.ui.text("This is a sample tool.")
        cave.ui.separator()

        self.counter = cave.ui.prop("Counter", self.counter)

        if cave.ui.buttonDark("Increase counter +1"):
            self.counter += 1
            print("Counter increased by +1")

यह कोड तब भी डिफ़ॉल्ट होता है जब आप एक एडिटर टैब जोड़ते हैं। यदि आप इसे प्रॉपर्टीज़ टैब में खोलते हैं और फिर एडिटर टूलिंग टैब में जाते हैं, तो आप example tab class को debug tab के रूप में देखेंगे। फिर बस आपको टैब को रजिस्टर या रीलोड करना होगा और यह UI में उपलब्ध हो जाएगा:

यह उदाहरण सरल है, लेकिन यह मूल विचार दिखाता है:

• cave.ui.DebugTab एक कस्टम एडिटर टैब बनाता है।
• draw() निर्धारित करता है कि टैब क्या दिखाता है।
• cave.ui.text() टेक्स्ट ड्रॉ करता है।
• cave.ui.prop() संपादन योग्य प्रॉपर्टी ड्रॉ करता है।
• cave.ui.buttonDark() एक बटन बनाता है।
• print() कंसोल को जानकारी भेजने के लिए इस्तेमाल किया जा सकता है।

यही तरीका Cave Editor के लिए कस्टम Tools बनाने का है। आप बाद में इस संरचना का उपयोग करके असली टूल बना सकते हैं।

draw() मेथड का अर्थ

draw() मेथड गेमप्ले कंपोनेंट के start() जैसा नहीं होता।

यह बार-बार कॉल होता है जब तक टूल दिख रहा होता है, क्योंकि एडिटर UI को ड्रॉ और अपडेट करना होता है। इसका मतलब है कि draw() के अंदर का कोड टूल की वर्तमान इंटरफ़ेस का विवरण देता है।

उदाहरण:

def draw(self):
    cave.ui.text("Level Helper:")

    if cave.ui.buttonDark("Create Enemy Group"):
        print("Create enemy group clicked")

टैब अपडेट होने पर बटन बार-बार ड्रॉ होता है, लेकिन if के अंदर का कोड सिर्फ तब चलता है जब उपयोगकर्ता बटन क्लिक करता है।

यह पैटर्न एडिटर टूल्स में बहुत सामान्य है।

एक व्यावहारिक टूल विचार

मान लीजिए आप एक स्तर बना रहे हैं और आपको अक्सर ये मूल फ़ोल्डर चाहिए:

• Environment
• Enemies
• Gameplay Triggers
• Lighting
• Audio
• Debug Helpers

आप एक एडिटर टूल बना सकते हैं जिसका बटन हो Create Level Folders। जब इसे क्लिक किया जाए, तो यह वर्तमान सीन में वे फ़ोल्डर्स Entities के रूप में बना सकता है। याद रखें: सीन ग्राफ में फ़ोल्डर बस एक Entity होता है जिस पर कोई कंपोनेंट संलग्न नहीं होता।

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

Editor Components

कभी-कभी, आप गेमप्ले लॉजिक के साथ एडिटर लॉजिक भी मिलाना चाहते हैं। उदाहरण के लिए, आप किसी entity से जुड़े एक component में एडिटर लॉजिक भी चाहते हैं, जैसे डिबग जानकारी दिखाना या दुश्मन के मूवमेंट या अटैक रेंज को दर्शाने वाला डिबग स्फीयर। इस स्थिति में, cave.Component के बजाय आप cave.EditorComponent का उपयोग करते हैं।

यह उपयोगी होता है जब entity को विशेष एडिटर व्यवहार की ज़रूरत हो, लेकिन वह व्यवहार वास्तविक गेम का हिस्सा नहीं होना चाहिए।

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

• एक spawn point एडिटर में सहायक जानकारी दिखा सकता है।
• एक trigger volume डिबग नियंत्रण प्रकट कर सकता है।
• एक लेवल मार्कर यह सत्यापित कर सकता है कि वह ठीक से कॉन्फ़िगर है या नहीं।

महत्वपूर्ण बात यह है कि एडिटर स्क्रिप्ट्स गेम बनाने के लिए नहीं, बल्कि गेम बनाने के कार्यप्रवाह के लिए होते हैं। गेमप्ले स्क्रिप्ट्स सीधे गेम के लिए होती हैं।

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

यह संभावित रूप से खतरनाक हो सकता है, उदाहरण के लिए: यदि आप start मेथड में ऐसा लॉजिक डालते हैं जो सीन में सारी entities को ढूंढकर डिलीट कर देता है, तो आपका गेम संपादक में पूरी तरह से नष्ट हो जाएगा और यह undo नहीं किया जा सकेगा। यह दोष नहीं है, यह कोई बग नहीं है, यह डिजाइन के अनुसार काम करने का तरीका है। इसलिए सावधान रहें।

यदि आप ऐसा सुरक्षित ढंग से करना चाहते हैं, तो Python Code Component का उपयोग करें, क्योंकि उसमें एक एडिटर अपडेट मेथड होता है, और उसका होना एडिटर में start और end अपडेट को प्रभावित नहीं करता (वे नहीं चलेंगे)। Cave के प्रारंभिक प्रोजेक्ट में Enemy को देखें, जो डिबग स्फीयर बनाने के लिए Python Code Component का उपयोग करता है, जो दुश्मनों के चारों ओर उस रेडियस को दर्शाता है जिसमें वे घूम सकते हैं। यह इसे सीखने का अच्छा तरीका है।

कब टूल बनाना चाहिए?

हर छोटे से छोटे काम के लिए कस्टम टूल न बनाएं।

टूल तब बनाएं जब वह वाकई वर्कफ़्लो समस्या हल करता हो, जैसे:

• आप बार-बार एक ही कार्य करते हैं।
• एक सेटअप भूलना आसान है।
• सीन की जाँच जरूरी है।
• डिज़ाइनर को मान बदलने के लिए साफ़-सुथरा इंटरफ़ेस चाहिए।
• प्रोटोटाइप के लिए तेज़ डिबग बटन चाहिए।

शुरुआती के लिए बेहतर होता है कि वे सबसे पहले गेम ऑब्जेक्ट मैन्युअल रूप से बनाएं। फिर जब कदम समझ में आ जाएं, तो बोरिंग भाग को स्वचालित करें।

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

Cave में Python का उपयोग गेमप्ले और एडिटर टूलिंग दोनों के लिए किया जा सकता है।

गेमप्ले स्क्रिप्ट्स नियंत्रित करती हैं कि गेम चलते समय क्या होता है। एडिटर स्क्रिप्ट्स आपको Cave Editor के अंदर प्रोजेक्ट बनाने, निरीक्षण करने, डिबग करने, या व्यवस्थित करने में मदद करती हैं।

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