Godot: GDScript विशेषता प्रणाली जोड़ें।

इसके बजाय क्या लाभ है: extends "res://move_right_trait.gd"

@MrJustreborn क्योंकि आपके पास एक कक्षा में कई लक्षण हो सकते हैं, लेकिन आप केवल एक स्क्रिप्ट को इनहेरिट कर सकते हैं।

अगर मैं सही ढंग से समझता हूं, तो यह मूल रूप से सी # कॉल " इंटरफेस " है, लेकिन गैर-सार विधियों के साथ? प्रोग्रामर से परिचित होने के लिए लक्षणों के बजाय फीचर इंटरफेस को कॉल करना बेहतर हो सकता है।

@aaronfranke लक्षण , मूल रूप से मिक्सिन के समान ही, इंटरफेस से बिल्कुल अलग उपयोग-मामला है क्योंकि उनमें विधियों के कार्यान्वयन शामिल हैं। यदि कोई इंटरफ़ेस डिफ़ॉल्ट कार्यान्वयन देता है, तो यह वास्तव में अब इंटरफ़ेस नहीं होगा।

PHP, Ruby, D, Rust, Haxe, Scala, और कई अन्य भाषाओं में लक्षण/मिक्सिन मौजूद हैं (जैसा कि लिंक किए गए विकी में विस्तृत है), इसलिए उन्हें पहले से ही उन लोगों से व्यापक रूप से परिचित होना चाहिए जिनके पास प्रोग्रामिंग भाषा परिचितता का व्यापक प्रदर्शन है।

यदि हम इंटरफेस (जिसका मैं विरोध नहीं कर रहा हूं, विशेष रूप से वैकल्पिक स्थैतिक टाइपिंग के साथ) को लागू करना था, तो यह प्रभावी रूप से फ़ंक्शन हस्ताक्षर निर्दिष्ट करने का एक तरीका होगा और उसके बाद प्रासंगिक जीडीस्क्रिप्ट स्क्रिप्ट उन फ़ंक्शन हस्ताक्षरों को लागू करने की आवश्यकता होगी लक्षणों के साथ शामिल हैं (यदि वे उस बिंदु तक मौजूद थे)।

शायद includes जैसा कोई कीवर्ड?

extends Node2D
includes TraitClass

हालांकि अन्य नाम जैसे विशेषता, मिश्रण, है, आदि निश्चित रूप से भी ठीक हैं।

मुझे ऐड मेनू से class_name प्रकार को बाहर करने के लिए कुछ विकल्प रखने का विचार भी पसंद है। यह छोटे प्रकारों के साथ बहुत अव्यवस्थित हो सकता है जो नोड्स के रूप में स्वयं कार्य नहीं करते हैं।

यह अपने आप में एक फीचर विषय भी हो सकता है।

(गलती से मेरी टिप्पणी हटा दी गई, ओह! इसके अलावा, अनिवार्य "आप कई स्क्रिप्ट की अनुमति क्यों नहीं देते, एकता यह करती है" )

विजुअलस्क्रिप्ट में यह कैसे काम करेगा, अगर बिल्कुल?

साथ ही, क्या लक्षणों के लिए एक इंस्पेक्टर इंटरफ़ेस शामिल करना फायदेमंद हो सकता है, यदि लक्षण लागू किए गए थे? मुझे लगता है कि लक्षणों के लिए कुछ उपयोग के मामलों में उन मामलों का उपयोग शामिल हो सकता है जहां केवल लक्षण हैं और कोई स्क्रिप्ट नहीं है (कम से कम, कोई स्क्रिप्ट नहीं है जिसमें विशेषता फ़ाइलें शामिल हैं)। हालाँकि, इसके बारे में अधिक सोचने पर, मुझे आश्चर्य होता है कि क्या इस तरह के इंटरफ़ेस को बनाने में किया गया प्रयास इसके लायक भी हो सकता है, केवल एक स्क्रिप्ट बनाने की तुलना में जिसमें विशेषता फ़ाइलें शामिल हैं।

@LikeLakers2

विजुअलस्क्रिप्ट में यह कैसे काम करेगा, अगर बिल्कुल?

यदि यह मेरे द्वारा सुझाए गए तरीके से किया जाता है, तो यह VisualScript के लिए बिल्कुल भी नहीं होगा। केवल जीडीस्क्रिप्ट। VisualScript के लिए लागू की गई कोई भी विशेषता प्रणाली पूरी तरह से अलग तरह से डिज़ाइन की जाएगी क्योंकि VisualScript एक पार्स की गई भाषा नहीं है। हालांकि संभावना को बिल्कुल भी नहीं रोकता है (बस इसे अलग तरह से लागू करने की आवश्यकता होगी)। साथ ही, शायद हमें पहले VisualScript इनहेरिटेंस-सपोर्ट प्राप्त करने पर विचार करना चाहिए? ज़ोर - ज़ोर से हंसना

साथ ही, क्या लक्षणों के लिए एक इंस्पेक्टर इंटरफ़ेस शामिल करना फायदेमंद हो सकता है, यदि लक्षण लागू किए गए थे?

कोई खास बात नहीं होगी। लक्षण केवल GDScript पर विवरण प्रदान करते हैं, इसे गुण, स्थिरांक, संकेत और विशेषता द्वारा परिभाषित विधियों को सौंपते हैं।

मुझे लगता है कि लक्षणों के लिए कुछ उपयोग के मामलों में उन मामलों का उपयोग शामिल हो सकता है जहां केवल लक्षण हैं और कोई स्क्रिप्ट नहीं है (कम से कम, कोई स्क्रिप्ट नहीं है जिसमें विशेषता फ़ाइलें शामिल हैं)।

लक्षण, जैसा कि वे अन्य भाषाओं में प्रस्तुत किए जाते हैं, अलगाव में कभी भी प्रयोग योग्य नहीं होते हैं, लेकिन प्रयोग करने योग्य होने के लिए उन्हें किसी अन्य लिपि में शामिल किया जाना चाहिए।

मुझे आश्चर्य है कि अगर ऐसा इंटरफ़ेस बनाने में किया गया प्रयास इसके लायक भी हो सकता है

किसी तरह से इंस्पेक्टर इंटरफ़ेस बनाना वास्तव में अकेले GDScript के लिए बहुत मायने नहीं रखता। किसी विशेषता को जोड़ने या हटाने में स्क्रिप्ट संसाधन की source_code संपत्ति के स्रोत कोड को सीधे संपादित करना शामिल होगा, अर्थात यह स्क्रिप्ट पर ही एक संपत्ति नहीं है। इसलिए या तो...

1. संपादक को यह सिखाया जाना होगा कि जीडीस्क्रिप्ट फाइलों के लिए स्रोत कोड के उचित संपादन को विशेष रूप से कैसे संभालना है (त्रुटि-प्रवण), या ...
2. सभी लिपियों को लक्षणों का समर्थन करना होगा ताकि GDScriptLanguage लक्षणों को जोड़ने और हटाने के लिए अपनी आंतरिक प्रक्रिया प्रदान कर सके (लेकिन सभी भाषाएं लक्षणों का समर्थन नहीं करती हैं, इसलिए संपत्ति सभी मामलों में सार्थक नहीं होगी)।

ऐसी सुविधा की क्या आवश्यकता है? क्या ऐसा कुछ है जो यह अनुमति देता है कि आप अभी नहीं कर सकते हैं? या क्या यह कुछ कार्यों से निपटने के लिए काफी तेज बनाता है?

मैं लगभग कभी उपयोग नहीं की गई जटिल सुविधाओं को जोड़ने के बजाय GDscript को एक सरल भाषा रखना चाहूंगा।

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

एकाधिक आयात/एकाधिक विरासत की अनुपस्थिति के साथ, कोड ए लॉट को दोहराने से बचने के लिए चाइल्ड-नोड्स-ए-स्क्रिप्ट-निर्भरता एकमात्र तरीका है, और यह निश्चित रूप से समस्या को एक अच्छे तरीके से हल करेगा।

@groud @Zireael07 मेरा मतलब है, अधिक कट्टरपंथी, क्रॉस-लैंग्वेज दृष्टिकोण 1 के लिए होगा) एक स्क्रिप्टस्टैक का उपयोग करने के लिए ऑब्जेक्ट को पूरी तरह से नया स्वरूप दें ताकि स्टैक्ड स्क्रिप्ट को एक स्क्रिप्ट प्रतिनिधित्व में समेटा जा सके, 2) मल्टीस्क्रिप्ट को फिर से पेश करें और संपादक समर्थन बनाएं जो स्वचालित रूप से परिवर्तित हो जाए मल्टीस्क्रिप्ट में लिपियों को जोड़ना (या सादगी के लिए सभी लिपियों को पूरी तरह से मल्टीस्क्रिप्ट बनाना, जिस स्थिति में मल्टीस्क्रिप्ट का कार्यान्वयन अनिवार्य रूप से हमारा स्क्रिप्टस्टैक होगा), या 3) ऑब्जेक्ट प्रकार के लिए एक प्रकार की क्रॉस-लैंग्वेज विशेषता प्रणाली को लागू करें जो इसमें विलय कर सके विशेषता के रूप में संदर्भ-विस्तारित स्क्रिप्ट, एक विशिष्ट स्क्रिप्ट की तरह उनकी सामग्री को शामिल करना। हालांकि ये सभी विकल्प इंजन के लिए अधिक आक्रामक हैं। यह सब कुछ आसान रखता है।

मुझे नहीं लगता कि विशेषता आवश्यक है। हमें जिस चीज की सबसे ज्यादा जरूरत है वह है तेज इंजन रिलीज चक्र। मेरा मतलब है कि हमें नई सुविधा जोड़ने के लिए इंजन को और अधिक लचीला बनाने की जरूरत है, बस नई डीएलएल या इतनी फाइलें जोड़ें और इंजन ऑटो को स्वयं के साथ एकीकृत करें, जैसे अधिकांश आईडीई में प्लगइन्स शैली। उदाहरण के लिए, मुझे वास्तव में वेबसोकेट को काम करने की सख्त जरूरत है, मुझे इसे रिलीज होने के लिए 3.1 तक इंतजार करने की जरूरत नहीं है। 3.1 बहुत सारे बग के साथ अभी टूटा हुआ है। यह बहुत अच्छा होगा अगर हमारे पास यह सुविधा है। नया वर्ग किसी पथ में यादृच्छिक .dll या .so से GDScript को स्वतः इंजेक्ट कर सकता है। मुझे नहीं पता कि सी ++ में यह कितना प्रयास करना है, लेकिन मुझे आशा है कि यह बहुत कठिन नहीं है

@ fian46 ठीक है, अगर किसी ने डाउनलोड करने योग्य GDNative प्लगइन के रूप में websockets को लागू किया था, तो हाँ, आपने जो वर्णन किया वह वर्कफ़्लो होगा। इसके बजाय, उन्होंने इसे वैनिला इंजन में एक एकीकृत सुविधा उपलब्ध कराने का विकल्प चुना। लोगों को इस तरह से सुविधाएँ बनाने से कोई रोक नहीं सकता है, इसलिए आपकी बात वास्तव में इस मुद्दे के विषय से संबंधित नहीं है।

ओह, मुझे नहीं पता कि GDNative मौजूद है . विशेषता बहुत बढ़िया है लेकिन क्या नकली विशेषता वर्ग बनाना और इसे उदाहरण देना और बाद में मूल स्क्रिप्ट की तरह फ़ंक्शन को कॉल करना आसान है?

यदि गोडोट लिपि एक अनाम वर्ग है, तो क्यों न "move_right_trait.gd" को "my_sprite.gd" में इंस्टेंस किया जाए?
मेरी अज्ञानता के लिए खेद है अगर मैं इस मुद्दे को समझ नहीं पा रहा हूं।

मैं अधिक दृढ़ता से टाइप की जाने वाली भाषाओं जैसे रस्ट या (इंटरफ़ेस इन) सी ++ में लक्षणों के उपयोग को समझता हूं, लेकिन एक डक टाइप की गई भाषा में यह थोड़ा अनावश्यक नहीं है? बस समान कार्यों को लागू करने से आपको अपने प्रकारों के बीच एक समान इंटरफ़ेस प्राप्त करने की अनुमति मिलनी चाहिए। मुझे लगता है कि मैं थोड़ा अनिश्चित हूं कि जीडीस्क्रिप्ट इंटरफेस को संभालने के तरीके के साथ सटीक समस्या क्या है या एक विशेषता प्रणाली वास्तव में कैसे मदद करेगी।

क्या आप मूल रूप से समान प्रभाव प्राप्त करने के लिए प्रीलोड ("कुछ-अन्य-व्यवहार। जीडी") का उपयोग नहीं कर सकते थे और परिणामों को एक चर में संग्रहीत नहीं कर सकते थे?

@fian46 @DriNeo खैर, हां और नहीं। स्क्रिप्ट लोड करना और स्क्रिप्ट कक्षाओं का उपयोग करना पहले से ही इसका ख्याल रखता है, लेकिन समस्या इससे आगे बढ़ती है।

@TheYokai

समान कार्यों को लागू करने से आपको अपने प्रकारों के बीच एक समान इंटरफ़ेस प्राप्त करने की अनुमति मिलनी चाहिए

समस्या एक समान इंटरफ़ेस प्राप्त नहीं कर रही है जो आप सही हैं, बतख-टाइपिंग ठीक हल करती है, बल्कि संबंधित कार्यान्वयन के समूहों को कुशलतापूर्वक व्यवस्थित (संयोजन/स्वैपिंग) करती है।

3.1 में, स्क्रिप्ट कक्षाओं के साथ, आप एक संदर्भ स्क्रिप्ट (या वास्तव में किसी भी प्रकार) पर स्थिर कार्यों को परिभाषित कर सकते हैं और फिर उस स्क्रिप्ट को जीडीस्क्रिप्ट में वैश्विक रूप से उन कार्यों तक पहुंचने के लिए नामस्थान के रूप में उपयोग कर सकते हैं।

extends Reference
class_name Game
static func print_text(p_text):
    print(p_text)
# can even add inner classes for sub-namespaces

extends Node
func _ready():
    Game.print_text("Hello World!")

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

उदाहरण के लिए, क्या होगा यदि मेरे पास काइनेमैटिक बॉडी 2 डी है और मैं "जंप" व्यवहार और "रन" व्यवहार करना चाहता हूं? इन व्यवहारों में से प्रत्येक को किनेमेटिकबॉडी2डी की इनपुट हैंडलिंग और move_and_slide सुविधाओं तक पहुंच की आवश्यकता होगी। आदर्श रूप से, मैं प्रत्येक व्यवहार के कार्यान्वयन को स्वतंत्र रूप से स्वैप करने और प्रत्येक व्यवहार के लिए सभी कोड को अलग-अलग लिपियों में रखने में सक्षम होऊंगा।

वर्तमान में, मैं इससे परिचित सभी कार्यप्रवाह इष्टतम नहीं हैं।

1. यदि आप सभी कार्यान्वयनों को एक ही स्क्रिप्ट में रखते हैं और केवल स्वैप करते हैं कि कौन से फ़ंक्शन का उपयोग किया जा रहा है ...
   
   
   
   1. "व्यवहार" बदलने में एक सेट के रूप में कई कार्यों की अदला-बदली शामिल हो सकती है, इसलिए आप कार्यान्वयन परिवर्तनों को प्रभावी ढंग से समूहित नहीं कर सकते।
   
   
   2. प्रत्येक व्यवहार (X * Y) के सभी कार्य आपकी एकल लिपि में बैठे हैं, इसलिए यह बहुत जल्दी फूला हुआ हो सकता है।
   
   
2. आप केवल पूरी स्क्रिप्ट को बदल सकते हैं, लेकिन फिर इसका मतलब है कि आपको व्यवहार के हर संयोजन के साथ-साथ उन व्यवहारों का उपयोग करने वाले किसी भी तर्क के लिए एक नई स्क्रिप्ट बनानी होगी।
3. यदि आप स्क्रिप्ट निर्भरता के रूप में चाइल्ड नोड्स का उपयोग करते हैं, तो इसका मतलब है कि आपके पास ये अजीब "घटक" Node2D नोड्स होंगे जो उनके माता-पिता को पकड़ लेंगे और इसके लिए move_and_slide विधि को कॉल करेंगे जो कि अप्राकृतिक, अपेक्षाकृत बोलने वाला है।
   
   
   
   • आपको यह धारणा बनानी होगी कि आपके माता-पिता उस पद्धति को लागू करने जा रहे हैं या यह जांचने के लिए तर्क करते हैं कि यह विधि है। और यदि आप एक जांच करते हैं, तो आप या तो चुपचाप विफल हो सकते हैं और संभावित रूप से आपके गेम में एक मूक बग हो सकता है या आप इसे टूल स्क्रिप्ट में अनावश्यक रूप से बदल सकते हैं ताकि आप नोड पर कॉन्फ़िगरेशन चेतावनी सेट कर सकें ताकि आपको संपादक में दृष्टि से बताया जा सके कि कोई समस्या है।
   
   
   • आपको नोड्स के इच्छित संचालन के लिए उचित कोड पूर्णता भी नहीं मिलती है क्योंकि वे Node2D से प्राप्त होते हैं और संपूर्ण बिंदु एक KinematicBody2D माता-पिता के व्यवहार को चलाने के लिए है।
   
   

अब, मैं मानता हूँ कि विकल्प 3 वर्तमान में सबसे प्रभावी कार्यप्रवाह है, और इसकी समस्याओं को 3.1 में जीडीस्क्रिप्ट के लिए हैंडी-डैंडी स्टैटिक टाइपिंग का उपयोग करके काफी हद तक हल किया जा सकता है। हालांकि, खेल में एक और मौलिक मुद्दा है।

गोडोट के नोड-सीन सिस्टम में आम तौर पर ऐसे उपयोगकर्ता होते हैं जो अपने स्वयं के संलग्न सिस्टम में नोड्स या दृश्य बनाते हैं जो एक विशेष कार्य करते हैं। आप उन नोड्स/दृश्यों को किसी अन्य दृश्य में इंस्टेंस कर सकते हैं और उनसे डेटा की गणना कर सकते हैं जो तब मूल दृश्य द्वारा उपयोग किया जाता है (जैसे कि एरिया 2 डी और CollisionShape2D संबंध के मामले में)।

हालांकि, वैनिला इंजन के उपयोग और सामान्य सर्वोत्तम प्रथाओं की सिफारिश है कि आप अपने दृश्य के व्यवहार को रूट नोड और/या इसकी स्क्रिप्ट पर लॉक रखें। शायद ही कभी आपके पास "व्यवहार घटक" नोड्स हों जो वास्तव में रूट को बताते हैं कि क्या करना है (और जब यह वहां होता है, तो यह बहुत भद्दा लगता है)। एनिमेशनप्लेयर/ट्वीन नोड्स एकमात्र तर्कपूर्ण अपवाद हैं जिनके बारे में मैं सोच सकता हूं, लेकिन यहां तक ​​​​कि उनके संचालन रूट द्वारा निर्देशित होते हैं (यह प्रभावी रूप से अस्थायी रूप से उन्हें नियंत्रण सौंप रहा है)। (संपादित करें: इस मामले में भी, एनिमेट करना और ट्विनिंग करना KinematicBody2D का काम नहीं है, इसलिए यह समझ में आता है कि उन कार्यों को प्रत्यायोजित किया जाएगा। हालांकि, चलना और कूदना इसकी जिम्मेदारी है ) यह अनुमति देना आसान और अधिक स्वाभाविक है कोड को व्यवस्थित करने के लिए एक विशेषता कार्यान्वयन क्योंकि यह नोड्स के बीच संबंधों को सख्ती से डेटा-अप/व्यवहार-डाउन रखता है और कोड को अपनी स्क्रिप्ट फ़ाइलों में अलग रखता है।

एह, खुद को 'इंटरफ़ेस/विशेषता को लागू करने' के रूप में चिह्नित करना भी * is * परीक्षण को पूरा करना चाहिए, जो किसी चीज़ की कार्यक्षमता का परीक्षण करने के लिए सुविधाजनक है।

@ OvermindDL1 मेरा मतलब है, मैंने इस तरह एक परीक्षण करने का एक उदाहरण दिया, लेकिन मैंने इसके बजाय in का उपयोग किया क्योंकि मैं विरासत और विशेषता-उपयोग के बीच अंतर करना चाहता था।

मुझे लगता है कि मैं थोड़े यहाँ एक XY समस्या में चला गया, मेरा बुरा। मैं अभी-अभी 2 अन्य मुद्दों (#23052, #15996) से आया था जिन्होंने इस विषय को किसी न किसी तरह से संबोधित किया और मुझे लगा कि मैं एक प्रस्ताव प्रस्तुत करूंगा, लेकिन मैंने वास्तव में सभी संदर्भ नहीं दिए।

@ यह समाधान # 19486 के खिलाफ उठाई गई समस्याओं में से एक को हल करेगा।

@willnationsdev महान विचार, मैं इसके लिए तत्पर हूं!

मेरी सीमित समझ से, यह विशेषता प्रणाली इस वीडियो में दिखाए गए वर्कफ़्लो के समान कुछ सक्षम करना चाहती है: https://www.youtube.com/watch?v=raQ3iHhE_Kk
(ध्यान रखें, मैं दिखाए गए _workflow_ के बारे में बात कर रहा हूं, न कि उपयोग की जाने वाली सुविधा के बारे में)

वीडियो में, इसकी तुलना अन्य प्रकार के वर्कफ़्लोज़ के साथ, उनके फायदे और नुकसान के साथ की गई है।

कम से कम मेरी जानकारी के लिए, इस तरह का वर्कफ़्लो GDScript में अभी असंभव है, क्योंकि इनहेरिटेंस कैसे काम करता है।

@AfterRebelion उस वीडियो के पहले कुछ मिनट जहां वह कोडबेस (और उन विशेषताओं के संबंधित विवरण) की प्रतिरूपकता, संपादन योग्यता और डिबगेबिलिटी को अलग करता है, वास्तव में इस सुविधा को प्राप्त करने का प्रयास है।

कम से कम मेरी जानकारी के लिए, इस तरह का वर्कफ़्लो GDScript में अभी असंभव है, क्योंकि इनहेरिटेंस कैसे काम करता है।

यह बिट बिल्कुल सच नहीं है, क्योंकि नोड पदानुक्रम और डिजाइनिंग दृश्यों के संबंध में गोडोट वास्तव में यह बहुत अच्छी तरह से करता है। दृश्य प्रकृति से मॉड्यूलर होते हैं, गुणों को कभी भी कोड से निपटने के बिना संपादक से सीधे निर्यात किया जा सकता है (और यहां तक ​​​​कि एनिमेटेड भी), और सब कुछ अलगाव में परीक्षण/डीबग किया जा सकता है क्योंकि दृश्यों को स्वतंत्र रूप से निष्पादित किया जा सकता है।

कठिनाई तब होती है जब तर्क जो आमतौर पर एक बच्चे के नोड को आउटसोर्स किया जाता है उसे रूट नोड द्वारा निष्पादित किया जाना चाहिए क्योंकि तर्क रूट नोड की विरासत सुविधाओं पर निर्भर करता है। इन मामलों में, रचना का उपयोग करने का एकमात्र तरीका यह है कि बच्चे माता-पिता को यह बताना शुरू कर दें कि उन्हें अपने स्वयं के व्यवसाय पर ध्यान देने के बजाय क्या करना है, जबकि माता-पिता उनका उपयोग करते हैं।

यह एकता में कोई समस्या नहीं है क्योंकि GameObject के पास कोई वास्तविक विरासत नहीं है जिसका उपयोगकर्ता लाभ उठा सकें। अवास्तविक में यह एक समस्या का थोड़ा (?) हो सकता है क्योंकि उनके पास अभिनेताओं के लिए समान नोड/घटक-आधारित आंतरिक पदानुक्रम हैं।

ठीक है, यहाँ थोड़ी देर के लिए डेविल्स एडवोकेट खेलते हैं ( @MysteryGM , आपको इससे फायदा हो सकता है)। इस बारे में सोचने में कुछ समय बिताया कि मैं इस तरह की प्रणाली को अवास्तविक में कैसे लिख सकता हूं और यह मुझे इस पर एक नया दृष्टिकोण दे रहा है। उन लोगों के लिए खेद है जो सोच रहे थे कि यह एक अच्छा विचार होगा / इसके बारे में उत्साहित थे:

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

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

यह वास्तव में एक भाषा के रूप में जीडीस्क्रिप्ट की डिबगेबिलिटी को टैंक करता है क्योंकि किसी भी समस्या के लिए आपको कोड बेस में औसतन 2 या 3 अलग-अलग स्थानों को चुनना पड़ सकता है। यदि उन स्थानों में से कोई भी कारण ढूंढना मुश्किल है तो वे कहते हैं कि वे एक स्क्रिप्ट में स्थित हैं लेकिन वास्तव में कहीं और स्थित हैं - और यदि कोड की पठनीयता स्पष्ट रूप से यह नहीं बताती है कि कौन सी चीज डेटा/तर्क के लिए ज़िम्मेदार है - तो वे 2 या 3 कदमों को मनमाने ढंग से बड़े, अत्यधिक तनावपूर्ण चरणों में गुणा किया जा रहा है।

एक परियोजना का बढ़ता आकार और दायरा इन नकारात्मक प्रभावों को और भी बढ़ा देता है और लक्षणों के उपयोग को एक बहुत ही अस्थिर गुण बना देता है।

लेकिन समस्या के समाधान के लिए क्या किया जा सकता है? हम नहीं चाहते कि बच्चा "घटक तर्क" नोड्स दृश्य जड़ों को बताए कि क्या करना है, लेकिन हम अपनी समस्या को हल करने के लिए विरासत या पूरी स्क्रिप्ट को बदलने पर भी भरोसा नहीं कर सकते हैं।

अच्छा, इस स्थिति में कोई गैर-ईसीएस इंजन क्या करेगा? संरचना अभी भी उत्तर है, लेकिन इस मामले में एक पूर्ण नोड अनुचित है जब स्वामित्व पदानुक्रम की गतिशीलता को स्केल/जटिल किया जाता है। इसके बजाय, कोई केवल गैर-नोड कार्यान्वयन वस्तुओं को परिभाषित कर सकता है जो किसी व्यवहार के ठोस कार्यान्वयन को दूर करते हैं, लेकिन जो अभी भी रूट नोड के स्वामित्व में हैं। यह Reference स्क्रिप्ट के साथ किया जा सकता है।

# root.gd
extends KinematicBody2D

export(Script) var jump_impl_script = null setget set_jump_impl_script
var jump_impl
func set_jump_impl_script(p_script):
    jump_impl = p_script.new() if p_script else null

export(Script) var move_impl_script = null setget set_move_impl_script
var move_impl
func set_move_impl_script(p_script):
    move_impl = p_script.new() if p_script else null

func _physics_process():
    # use logic involving these...
    move_impl.move(...)
    jump_impl.jump(...)

यदि निर्यात इस तरह से काम करता है कि हम उन्हें इंस्पेक्टर में उन वर्गों के लिए एनम के रूप में संपादित कर सकते हैं जो एक विशेष प्रकार प्राप्त करते हैं जैसे हम नए संसाधन उदाहरणों के लिए कर सकते हैं, तो यह अच्छा होगा। ऐसा करने का एकमात्र तरीका अब संसाधन स्क्रिप्ट निर्यात को ठीक करना होगा और फिर अपनी कार्यान्वयन स्क्रिप्ट को संसाधन का विस्तार करना होगा (बिना किसी कारण के)। हालांकि, उन्हें संसाधन का विस्तार करना एक अच्छा विचार होगा यदि कार्यान्वयन के लिए स्वयं उन मापदंडों की आवश्यकता होती है जिन्हें आप निरीक्षक से परिभाषित करने में सक्षम होना चाहते हैं। :-)

अब, जो इसे आसान बना देगा वह होगा एक स्निपेट सिस्टम या मैक्रो सिस्टम ताकि डेवलपर्स के लिए उन पुन: उपयोग किए गए घोषणात्मक कोड अनुभागों को बनाना आसान हो।

वैसे भी, हाँ, मुझे लगता है कि मैंने एक विशेषता प्रणाली और समस्या को हल करने के लिए एक बेहतर दृष्टिकोण के साथ चकाचौंध वाले मुद्दों की पहचान की। XY समस्या के मुद्दों के लिए हुर्रे! /एस

संपादित करें:

तो, उपरोक्त उदाहरण के वर्कफ़्लो में कार्यान्वयन स्क्रिप्ट को सेट करना और फिर व्यवहार को परिभाषित करने के लिए रनटाइम पर स्क्रिप्ट के उदाहरण का उपयोग करना शामिल होगा। लेकिन क्या होगा यदि कार्यान्वयन के लिए स्वयं उन मापदंडों की आवश्यकता होती है जिन्हें आप इंस्पेक्टर से स्थिर रूप से सेट करना चाहते हैं? इसके बजाय संसाधन पर आधारित एक संस्करण यहां दिया गया है।

# root.gd
extends KinematicBody2D

# if you use a Resource script AND had a way of specifying that the assigned Resource 
# must extend that script, then the editor would automatically assign an instance of 
# that resource script to the var. No separate instancing or setter necessary.

export(Resource) var jump_impl = null # set jump duration, max height, tween easing via Inspector
export(Resource) var move_impl = null # similarly customize movement from Inspector

# can then create different Resources as different implementations. Because they are resources,
# one can edit them even outside of a scene!
func _physics_process():
    move_impl.move(...)
    jump_impl.jump(...)

संबंधित: #22660

@आफ्टररेबेलियन

ध्यान रखें, मैं दिखाए गए कार्यप्रवाह के बारे में बात कर रहा हूं, न कि उपयोग की जाने वाली सुविधा के बारे में

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

# root.gd
extends KinematicBody2D

export(Script) var jump_impl_script = null setget set_jump_impl_script
var jump_impl
func set_jump_impl_script(p_script):
jump_impl = p_script.new() if p_script else null
...

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

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

@आफ्टररेबेलियन

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

ठीक है, जिस Resource -आधारित दृष्टिकोण का मैंने उसी टिप्पणी में उल्लेख किया है, जो #22660 से कुछ बेहतर संपादक समर्थन के साथ संयुक्त है, गुणवत्ता को एकता की तुलना में तुलनीय बना देगा।

हो सकता है कि एकता की तरह बहुमुखी न हो, क्योंकि आपको अभी भी हर संभव स्क्रिप्ट को पहले से घोषित करने की आवश्यकता होगी, लेकिन फिर भी एक अच्छा विकल्प होगा।

ठीक है, अगर वे 3.2 में सरणी प्रकार के संकेतों को ठीक करते हैं, तो आप फ़ाइल पथों के लिए एक निर्यातित सरणी को परिभाषित कर सकते हैं जो एक स्क्रिप्ट का विस्तार करना चाहिए और प्रभावी रूप से अपना खुद का जोड़ना चाहिए। यह कुछ संसाधनों या नोड्स के लिए इंस्पेक्टर को कस्टम सामग्री जोड़ने के लिए EditorInspectorPlugin वर्ग का उपयोग करके 3.1 में एक प्लगइन के माध्यम से भी किया जा सकता है।

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

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

खैर, जब मैं बाहर था तब मैं इस चर्चा से चूक गया। अभी तक सब कुछ नहीं पढ़ा है, लेकिन मेरे पास कोड के पुन: उपयोग की समस्या को हल करने के लिए GDScript में लक्षण जोड़ने का विचार था, जो मुझे एक स्क्रिप्ट को व्युत्पन्न प्रकार से जोड़ने की अशुद्ध एकाधिक विरासत की तुलना में अधिक सुरुचिपूर्ण और स्पष्ट लगता है। हालाँकि मैं जो करूँगा वह विशिष्ट विशेषता फ़ाइलें बना रहा था, किसी भी वर्ग फ़ाइल को एक विशेषता होने की अनुमति नहीं दे रहा था। मुझे नहीं लगता कि यह बहुत बुरा होगा।

लेकिन मैं मुख्य मुद्दे को हल करने के लिए सुझावों के लिए खुला हूं, जो कई नोड प्रकारों में कोड का पुन: उपयोग कर रहा है।

@vnen जिस समाधान के साथ मैं आया था, वह अंतिम आइटम संसाधन स्क्रिप्ट के लिए पुन: उपयोग करने योग्य अनुभागों को आउटसोर्स करना है।

• उन्हें अभी भी उजागर किया जा सकता है और उनकी संपत्तियों को इंस्पेक्टर में संपादित किया जा सकता है, जैसे कि वे नोड पर सदस्य चर थे।

• वे एक स्पष्ट निशान को संरक्षित करते हैं कि डेटा और तर्क कहां से आ रहे हैं, कुछ ऐसा जो आसानी से समझौता किया जा सकता है यदि कई लक्षणों को एक स्क्रिप्ट में शामिल किया गया हो।

• वे भाषा के रूप में GDScript में कोई अनुचित जटिलता नहीं जोड़ते हैं। उदाहरण के लिए, यदि वे मौजूद हैं, तो हमें यह तय करना होगा कि साझा गुण (गुण, स्थिरांक, संकेत) को मुख्य स्क्रिप्ट में कैसे विलय किया जाएगा (या, यदि विलय नहीं किया गया है, तो उपयोगकर्ताओं को निर्भरता संघर्षों से निपटने के लिए मजबूर करें)।

• संसाधन स्क्रिप्ट बेहतर हैं क्योंकि उन्हें निरीक्षक से सौंपा और बदला जा सकता है। डिजाइनर, लेखक, आदि सीधे संपादक से कार्यान्वयन वस्तुओं को बदलने में सक्षम होंगे।

@willnationsdev मैं देखता हूं (हालांकि "संसाधन स्क्रिप्ट" नाम अजीब लगता है, क्योंकि सभी स्क्रिप्ट संसाधन हैं)। इस समाधान के साथ मुख्य मुद्दा यह है कि यह कुछ ऐसा हल नहीं करता है जिसे लोग विरासत दृष्टिकोण से उम्मीद करते हैं: दृश्य के रूट नोड में निर्यात किए गए चर और सिग्नल जोड़ना (विशेष रूप से जब दृश्य कहीं और इंस्टेंस करना)। आप अभी भी उप-संसाधनों से निर्यात किए गए चर संपादित कर सकते हैं, लेकिन यह कम व्यावहारिक हो जाता है (आप एक नज़र में यह नहीं बता सकते कि आप किन गुणों को संपादित कर सकते हैं)।

दूसरा मुद्दा यह है कि इसके लिए बॉयलरप्लेट कोड को बहुत बार दोहराने की आवश्यकता होती है। आपको यह भी सुनिश्चित करना होगा कि फ़ंक्शन को कॉल करने से पहले संसाधन स्क्रिप्ट वास्तव में सेट की गई हैं।

फायदा यह है कि हमें किसी चीज की जरूरत नहीं है, यह पहले से ही उपलब्ध है। मुझे लगता है कि इसे प्रलेखित किया जाना चाहिए और वर्तमान "स्क्रिप्ट को व्युत्पन्न नोड में संलग्न करें" विधि का उपयोग करने वाले लोग समाधान पर टिप्पणी कर सकते हैं कि यह कितना व्यवहार्य है।

@vnen

लेकिन यह कम व्यावहारिक हो जाता है (आप एक नज़र में नहीं बता सकते कि आप किन गुणों को संपादित कर सकते हैं)।

क्या आप यहां विस्तार से बता सकते हैं कि आपका क्या मतलब है? मैं यह नहीं देखता कि स्पष्टता की कोई पर्याप्त कमी कैसे हो सकती है कि कौन सी संपत्तियां सुलभ हैं, खासकर अगर # 22660 जैसी किसी चीज़ को मिला दिया गया हो।

1. मैं दृश्य का उदाहरण देता हूं, जानना चाहता हूं कि मैं इसे कैसे संपादित कर सकता हूं, और इसलिए उस दृश्य के रूट नोड की स्क्रिप्ट को देखें।
2. स्क्रिप्ट के अंदर, मैं देखता हूं ...
   
   
   
   • export(MoveImpl) var move_impl = FourWayMoveImpl.new()
   
   
   • use FourWayMoveTrait
   
   
3. यह मानते हुए कि स्क्रिप्ट को खोलने के लिए हमारे पास पहचानकर्ता को क्लिक-ट्रेसिंग करने का एक साधन है (जो वास्तव में एक 3.1.1 विशेषता होनी चाहिए!), हम तब संबंधित स्क्रिप्ट को खोलते हैं और इसके गुणों को देख सकते हैं।

मेरे लिए समान चरणों की तरह लगता है, जब तक कि मुझे कुछ याद नहीं आ रहा है।

इसके अलावा, कौन से गुण संपादन योग्य हैं, वास्तव में संसाधनों के साथ और भी स्पष्ट है, मैं कहूंगा कि, यदि किसी कार्यान्वयन में इसके लिए विशिष्ट गुण हैं, तो तथ्य यह है कि डेटा कार्यान्वयन से संबंधित है, यदि आपको इसे एक्सेस करने की प्रस्तावना है तो यह अधिक स्पष्ट है। कार्यान्वयन उदाहरण, यानी move_impl.<property> ।

दूसरा मुद्दा यह है कि इसके लिए बॉयलरप्लेट कोड को बहुत बार दोहराने की आवश्यकता होती है। आपको यह भी सुनिश्चित करना होगा कि फ़ंक्शन को कॉल करने से पहले संसाधन स्क्रिप्ट वास्तव में सेट की गई हैं।

यह सच है, हालांकि, मुझे अभी भी लगता है कि इसके प्रारंभिकरण के साथ निर्यात होने का लाभ अतिरिक्त क्रिया की लागत से अधिक है:

("हाई-लेवल टीममेट", HLT, जैसे डिज़ाइनर, लेखक, कलाकार, आदि)

• स्क्रिप्ट को खोलने, बदलने के लिए सही लाइन का पता लगाने, और फिर इसे बदलने (पहले से ही उल्लेख किया गया है, लेकिन यह आगे बढ़ता है ...) के बजाय, कोई सीधे इंस्पेक्टर से मान निर्दिष्ट कर सकता है।

• कोई यह निर्दिष्ट कर सकता है कि निर्यात की गई सामग्री के लिए आधार प्रकार की आवश्यकता है। निरीक्षक तब स्वचालित रूप से स्वीकार्य कार्यान्वयन की एक गणना सूची प्रदान कर सकता है। एचएलटी तब सुरक्षित रूप से केवल उस प्रकार की व्युत्पत्तियां निर्दिष्ट कर सकते हैं। यह उन्हें चारों ओर तैरने वाली सभी विभिन्न विशेषता लिपियों के प्रभाव को जानने की आवश्यकता के विकल्प से बचाने में मदद करता है। हमें use कीवर्ड देखने के जवाब में नामित और अनाम विशेषता फ़ाइलों को देखने का समर्थन करने के लिए जीडीस्क्रिप्ट में स्वत: पूर्णता को भी संशोधित करना होगा।

• कोई कार्यान्वयन के कॉन्फ़िगरेशन को *.tres फ़ाइल के रूप में क्रमबद्ध कर सकता है। एचएलटी तब उन्हें फाइलसिस्टम डॉक से ड्रैग-एंड-ड्रॉप कर सकते हैं या यहां तक ​​कि इंस्पेक्टर में अपना अधिकार भी बना सकते हैं। यदि कोई लक्षणों के साथ भी ऐसा ही करना चाहता है, तो उन्हें एक व्युत्पन्न विशेषता बनानी होगी जो डिफ़ॉल्ट कंस्ट्रक्टर को ओवरराइड करने के लिए एक कस्टम कंस्ट्रक्टर प्रदान करे। फिर वे अनिवार्य रूप से कोडित कंस्ट्रक्टर के माध्यम से उस विशेषता का उपयोग "पूर्व-कॉन्फ़िगरेशन" के रूप में करेंगे।

  1. कमजोर इसलिए क्योंकि यह घोषणात्मक के बजाय अनिवार्य है।
  2. कमजोर क्योंकि कंस्ट्रक्टर को स्क्रिप्ट में स्पष्ट रूप से परिभाषित किया जाना चाहिए।
  3. यदि विशेषता का नाम नहीं है, तो उपयोगकर्ता को यह जानने की आवश्यकता होगी कि डिफ़ॉल्ट, आधार विशेषता के बजाय इसका ठीक से उपयोग करने के लिए विशेषता कहाँ स्थित है। यदि विशेषता का नाम दिया गया है, तो यह वैश्विक नामस्थान को अनावश्यक रूप से बंद कर देता है।
  4. यदि वे $#$ use MoveTrait $#$ के बजाय use FourWayMoveTrait कहने के लिए स्क्रिप्ट बदलते हैं, तो अब कोई स्थायी संकेत नहीं है कि स्क्रिप्ट आधार MoveTrait के साथ भी संगत है। यह एचएलटी भ्रम को सक्षम बनाता है कि क्या FourWayMoveTrait चीजों को तोड़े बिना एक अलग MoveTrait में भी बदल सकता है।
  5. यदि कोई एचएलटी इस तरह से एक नया विशेषता कार्यान्वयन बना रहा था, तो वे आवश्यक रूप से उन सभी गुणों को नहीं जान पाएंगे जिन्हें मूल विशेषता से सेट किया जा सकता है। यह निरीक्षक में बनाए गए संसाधनों के साथ एक गैर-मुद्दा है।

• किसी के पास एक ही प्रकार के कई संसाधन भी हो सकते हैं (यदि उसके लिए कोई कारण था)। एक विशेषता इसका समर्थन नहीं करेगी, बल्कि इसके बजाय पार्स संघर्षों को ट्रिगर करेगी।

• कोई भी 2D/3D व्यूपोर्ट को छोड़े बिना कॉन्फ़िगरेशन और/या उनके व्यक्तिगत मूल्यों को बदल सकता है। यह एचएलटी के लिए बहुत अधिक आरामदायक है (मैं बहुत कुछ जानता हूं जो एकमुश्त नाराज हो जाते हैं जब उन्हें कोड को बिल्कुल भी देखना पड़ता है)।

उस सब के साथ, मैं मानता हूं कि बॉयलरप्लेट कष्टप्रद है। हालांकि इससे निपटने के लिए, मैं इसे सरल बनाने के लिए मैक्रो या स्निपेट सिस्टम जोड़ना चाहूंगा। एक स्निपेट सिस्टम एक अच्छा विचार होगा क्योंकि यह केवल GDScript के बजाय ScriptEditor में संपादित की जा सकने वाली किसी भी भाषा का अनुमानतः समर्थन कर सकता है।

के बारे में:

लेकिन यह कम व्यावहारिक हो जाता है (आप एक नज़र में नहीं बता सकते कि आप किन गुणों को संपादित कर सकते हैं)।

मैं इंस्पेक्टर के बारे में बात कर रहा था, इसलिए मेरा मतलब यहाँ "HLT" से है। जो लोग कोड में नहीं देखेंगे। लक्षणों के साथ हम स्क्रिप्ट में नए निर्यात किए गए गुण जोड़ सकते हैं। संसाधन स्क्रिप्ट के साथ आप केवल संसाधन में ही चर निर्यात कर सकते हैं, इसलिए जब तक आप उपसंसाधन को संपादित नहीं करते, तब तक वे निरीक्षक में नहीं दिखाई देंगे।

मैं आपका तर्क समझता हूं लेकिन यह मूल समस्या से परे है: कोड दोहराने से बचें (विरासत के बिना)। गुण प्रोग्रामर के लिए हैं। कई मामलों में केवल एक ही कार्यान्वयन है जिसे आप पुन: उपयोग करना चाहते हैं, और आप इसे निरीक्षक में उजागर नहीं करना चाहते हैं। बेशक आप अभी भी सीधे कोड में निर्दिष्ट करके निर्यात किए बिना संसाधन स्क्रिप्ट का उपयोग कर सकते हैं, लेकिन फिर भी सामान्य कार्यान्वयन से निर्यात किए गए चर और संकेतों के पुन: उपयोग की समस्या का समाधान नहीं करते हैं, जो मुख्य कारणों में से एक है जो लोग कोशिश कर रहे हैं। विरासत का उपयोग करें।

यही है, लोग वर्तमान में न केवल कार्यों के लिए, बल्कि निर्यात की गई संपत्तियों (जो आमतौर पर उन कार्यों से संबंधित होते हैं) और सिग्नल (जो तब UI से जुड़े हो सकते हैं) के लिए एक सामान्य स्क्रिप्ट से विरासत का उपयोग करने का प्रयास कर रहे हैं।

यह हल करना कठिन समस्या है। अकेले जीडीस्क्रिप्ट के साथ ऐसा करने के कुछ तरीके हैं, लेकिन फिर से उन्हें बॉयलरप्लेट कोड की प्रतिलिपि बनाने की आवश्यकता होती है।

मैं केवल कल्पना कर सकता हूं कि बाहरी लिपियों को ऐसा व्यवहार करने के लिए आगे और पीछे करना होगा जैसे कि वे सीधे मुख्य लिपि में ही लिखे गए हों।

यह एक अच्छी बात होगी यदि इसे प्राप्त करने के लिए स्वर्ग और पृथ्वी को स्थानांतरित करने की आवश्यकता नहीं है। एक्स)

@vnen मैं देख रहा हूँ कि अब आप क्या कह रहे हैं। ठीक है, चूंकि ऐसा लगता है कि इस अंक में अभी भी कुछ जान बाकी है, मैं अगली बार मौका मिलने पर इसे फिर से खोलूंगा।

इसे फिर से खोलने पर कोई खबर? अब जबकि GodotCon 2019 की घोषणा हो चुकी है, और Godot Sprint एक चीज है, शायद यह वहां बात करने लायक है।

@AfterRebelion मैं बस वापस आना और उसे फिर से खोलना भूल गया था। मुझे याद दिलाने के लिये धन्यवाद। एक्सडी

@willnationsdev मुझे वह पसंद आया जो मैंने EditorInspectorPlugin के बारे में पढ़ा! त्वरित प्रश्न, इसका मतलब है कि मैं डेटा प्रकार के लिए एक कस्टम इंस्पेक्टर बना सकता हूं ... उदाहरण के लिए ... इंस्पेक्टर को एक बटन जोड़ें।
(काफी समय हो गया है जब से मैं ऐसा करना चाहता था, निरीक्षक में एक बटन के साथ डिबगिंग उद्देश्यों के लिए घटनाओं को ट्रिगर करने का एक तरीका है, मैं बटन प्रेस को कुछ स्क्रिप्ट निष्पादित कर सकता हूं)

@xDGameStudios हाँ, वह और भी बहुत कुछ संभव है। किसी भी कस्टम नियंत्रण को निरीक्षक में जोड़ा जा सकता है, या तो शीर्ष पर, नीचे, किसी संपत्ति के ऊपर, या किसी श्रेणी के नीचे।

@willnationsdev मुझे नहीं पता कि मैं आपसे निजी संदेश के जरिए संपर्क कर सकता हूं या नहीं !! लेकिन मैं EditorInspectorPlugin (कुछ नमूना कोड की तरह) के बारे में और जानना चाहता हूं .. कस्टम संसाधन प्रकार की पंक्तियों में कुछ (उदाहरण के लिए) MyResource जिसमें एक संपत्ति निर्यात "नाम" और एक निरीक्षक बटन है जो "नाम" प्रिंट करता है चर अगर मैं इसे दबाता हूं (संपादक में या डिबगिंग के दौरान)! इस मामले में दस्तावेज़ीकरण में बहुत समय की कमी है ... अगर मैं जानता था कि इसका उपयोग कैसे करना है तो मैं स्वयं दस्तावेज़ीकरण लिखूंगा! :डी धन्यवाद

मैं इसके बारे में और जानना चाहूंगा। एक्स)

तो क्या यह स्थिर कार्यों वाले उपवर्गों के साथ एक ऑटोलैड स्क्रिप्ट के समान है?

उदाहरण के लिए आपका मामला Traits.MoveRightTrait.move_right() बन जाएगा

या इससे भी सरल, विभिन्न विशेषता वर्गों के लिए अलग-अलग ऑटोलैड स्क्रिप्ट वाले:

Movement.move_right()

नहीं, लक्षण एक भाषा-विशिष्ट विशेषता है जो एक स्क्रिप्ट के स्रोत कोड को दूसरी स्क्रिप्ट में कॉपी-पेस्ट करने के बराबर है (थोड़ा फ़ाइल-मर्ज की तरह)। तो अगर मेरे पास move_right() के साथ एक विशेषता है, और फिर मैं घोषणा करता हूं कि मेरी दूसरी स्क्रिप्ट उस विशेषता का उपयोग करती है, तो यह भी move_right() का उपयोग कर सकती है, भले ही यह स्थिर न हो और यहां तक ​​​​कि अगर यह एक्सेस करता है वर्ग में कहीं और गुण। यदि संपत्ति दूसरी लिपि में मौजूद नहीं थी तो इसका परिणाम केवल एक पार्स त्रुटि में होगा।

मैंने पाया है कि मेरे पास या तो डुप्लीकेट कोड है (छोटे फ़ंक्शन, उदाहरण के लिए एक चाप बनाना) या अनावश्यक नोड्स क्योंकि मेरे पास एकाधिक विरासत नहीं हो सकती है।

यह बहुत बढ़िया होगा, मैं खुद को ठीक उसी कार्यक्षमता के साथ एक स्क्रिप्ट बनाने के लिए पाता हूं जिसका उपयोग विभिन्न नोड प्रकारों पर अलग-अलग extend s के कारण मूल रूप से कोड की एक पंक्ति के लिए किया जाता है। वैसे अगर कोई जानता है कि मौजूदा सिस्टम के साथ इसे कैसे बनाया जाए तो मुझे बताएं।

अगर मेरे पास extends Node वाली स्क्रिप्ट के लिए कार्यक्षमता है, तो क्या स्रोत फ़ाइल को डुप्लिकेट किए बिना और उचित extend के साथ प्रतिस्थापित किए बिना समान व्यवहार को किसी अन्य नोड प्रकार से जोड़ने का कोई तरीका है?

उस पर कोई प्रगति? जैसा कि मैंने पहले कहा था, मुझे कोड डुप्लिकेट करना पड़ता है या नोड्स जोड़ना पड़ता है। मुझे पता है कि यह 3.1 में नहीं किया जाएगा, लेकिन शायद 3.2 का लक्ष्य है?

ओह, मैं इस पर बिल्कुल भी काम नहीं कर रहा हूं। वास्तव में, मैं इसके बजाय अपने विस्तार विधि कार्यान्वयन पर आगे हूं। मुझे उन दोनों के बारे में बात करने की ज़रूरत है, हालांकि मैं उनके साथ सबसे अच्छा वाक्यविन्यास/कार्यान्वयन विवरण तैयार करना चाहता हूं।

संपादित करें: यदि कोई अन्य व्यक्ति लक्षणों को लागू करने में दरार लेना चाहता है, तो इसमें कूदने के लिए उनका स्वागत है। बस देवों से तालमेल बिठाने की जरूरत है।

"विस्तार विधि कार्यान्वयन"?

@Zireal07 #15586
यह लोगों को स्क्रिप्ट लिखने की अनुमति देता है जो इंजन कक्षाओं के लिए नए "अंतर्निहित" कार्यों को जोड़ सकता है। वाक्य रचना की मेरी व्याख्या कुछ इस तरह होगी:

static Array func sum(p_self: Array):
    if not len(p_self):
        return 0
    var value = p_self[0]
    for i in range(1, len(p_self)):
        value += p_self[i]
    return value

फिर, कहीं और, मैं बस ऐसा कर पाऊंगा:

var arr = [1, 2, 3]
print(arr.sum()) # prints 6

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

मैंने इस बारे में @vnen और @jahd2602 से कुछ बातचीत की है। एक बात जो दिमाग में आती है वह है जय का बहुरूपता का समाधान: एक संपत्ति का नाम स्थान आयात करना।

इस तरह, आप निम्न की तरह कुछ कर सकते हैं:

class A:
    var a_prop: String = "Hello"
    func foo():
        print("A's a_prop: ", a_prop)
    func bar():
        print("A's bar()")

class B:
    using var a: A = A.new()
    var a_prop: String = "World" # Overriding A's a_prop

    func bar():  # Overriding A's bar()
        print("B's bar()")

func main():
    var b: B = B.new()
    b.foo() # output: "A's a_prop: World"
    b.bar() # output: "B's bar()"

मुद्दा यह है कि using कीवर्ड किसी संपत्ति के नामस्थान को आयात करता है, जैसे कि b.foo() वास्तव में b.a.foo() के लिए केवल वाक्यात्मक चीनी है।

और फिर, सुनिश्चित करें कि b is A == true और उस B का उपयोग टाइप की गई स्थितियों में किया जा सकता है जो A को भी स्वीकार करते हैं।

इसका यह भी लाभ है कि चीजों को लक्षण के रूप में घोषित करने की आवश्यकता नहीं है, यह किसी भी चीज के लिए काम करेगा जिसमें सामान्य गुणवत्ता वाले नाम नहीं हैं।

एक समस्या यह है कि यह वर्तमान विरासत प्रणाली के साथ अच्छी तरह से मेल नहीं खाता है। यदि A और B दोनों Node2D हैं और हम A: func baz(): print(self.position) में एक फ़ंक्शन बनाते हैं, तो जब हम b.baz() पर कॉल करेंगे तो कौन सी स्थिति मुद्रित होगी?
एक समाधान यह हो सकता है कि कॉलर self निर्धारित करे। b.foo() को कॉल करना foo() को b के साथ स्वयं और bafoo() को foo() को स्वयं के रूप में कॉल करेगा।

यदि हमारे पास पाइथन (जहां x.f(y) के लिए चीनी है f(x,y) ) जैसी फ्रीस्टैंडिंग विधियां हैं, तो इसे कार्यान्वित करना वाकई आसान हो सकता है।

एक और, असंबंधित विचार:

केवल फ्रीस्टैंडिंग फ़ंक्शंस, जावास्क्रिप्ट शैली पर ध्यान दें।

यदि हम स्थिर कार्यों के लिए x.f(y) == f(x,y) सम्मेलन को अपनाते हैं, तो हम बहुत आसानी से निम्नलिखित प्राप्त कर सकते हैं:

class Jumper:
    static func jump(_self: KinematicBody2D):
        # jump implementation

class Runner:
    static func run(_self: KinematicBody2D, direction: Vector2):
        # run implementation

class Character:
    extends KinematicBody2D
    func run = Runner.run       # Example syntax
    func jump = Jumper.jump

func main():
    var character = Character.new()
    character.jump()
    character.run(Vector2(1,0))

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

@jabcross अच्छा लगता है, मुझे किसी प्रकार के वैकल्पिक नेमस्पेसिंग की अवधारणा पसंद है, और फ़ंक्शन विचार दिलचस्प है।

नेमस्पेस एक के बारे में, मुझे आश्चर्य है कि क्यों न केवल using A , अन्य घोषणात्मक चीजें बाहरी लगती हैं।

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

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

A.gd के शीर्ष पर:

extends Trait as Node2D
is Trait as Node2D
is Trait extends B
extends B as Trait

ओह्ह, मुझे वास्तव में नेमस्पेस आयात करने की अवधारणा पसंद है। यह न केवल विशेषता समस्या को हल करता है, बल्कि इंजन प्रकारों में सामग्री जोड़ने के लिए संभावित रूप से "विस्तार विधियों" अवधारणा को भी हल करता है।

class_name ArrayExt
static func sum(_self: Array) -> int:
    var sum: int = 0
    for a_value in _self:
        sum += a_value
    return sum

using ArrayExt
func _ready():
    var a = [1, 2, 3]
    print(a.sum())

@jabcross अगर हमने कॉल ऑपरेटर को लागू करने के लिए लैम्बस और/या ऑब्जेक्ट्स को भी जोड़ा (और संगत मानों के लिए callable प्रकार था), तो हम GDScript कोड में अधिक कार्यात्मक-उन्मुख दृष्टिकोण जोड़ना शुरू कर सकते हैं (जो मुझे लगता है कि यह एक अच्छा विचार होगा)। दी गई, उस समय @vnen के #18698 क्षेत्र में अधिक घूमना, लेकिन...

हमें यह विचार करना होगा कि जीडीस्क्रिप्ट अभी भी एक गतिशील भाषा है और उनमें से कुछ सुझावों के लिए कॉल को सही ढंग से भेजने के लिए रनटाइम चेक की आवश्यकता होती है, एक प्रदर्शन जुर्माना (यहां तक ​​​​कि उन लोगों के लिए जो सुविधाओं का उपयोग नहीं करते हैं, क्योंकि इसे सभी फ़ंक्शन कॉल की जांच करने की आवश्यकता होती है) और शायद संपत्ति लुकअप भी)। यही कारण है कि मुझे यकीन नहीं है कि एक्सटेंशन जोड़ना एक अच्छा विचार है (खासकर जब से वे अनिवार्य रूप से सिंटैक्स चीनी हैं)।

मैं शुद्ध विशेषता प्रणाली पसंद करता हूं, जहां लक्षण वर्ग नहीं बल्कि स्वयं की चीज हैं। इस तरह उन्हें संकलन समय में पूरी तरह से हल किया जा सकता है, और नाम विरोध के मामलों में त्रुटि संदेश प्रदान कर सकते हैं। मेरा मानना ​​​​है कि यह अतिरिक्त रनटाइम ओवरहेड के बिना इस मुद्दे को हल करेगा।

@vnen आह, यह नहीं पता था कि रनटाइम लागत के बारे में। और अगर यह किसी भी विस्तार विधि कार्यान्वयन पर लागू होता है, तो मुझे लगता है कि यह आदर्श भी नहीं होगा।

यदि हमने एक शुद्ध विशेषता प्रणाली की थी, तो क्या आप अन्य लिपियों में विस्तार के तहत using TraitName के साथ जोड़े गए extends trait TraitName बनाने के बारे में सोच रहे थे? और क्या आप इसे स्वयं लागू कर रहे होंगे, या इसे प्रत्यायोजित किया जाएगा?

यदि हमने एक शुद्ध विशेषता प्रणाली की थी, तो क्या आप अन्य लिपियों में विस्तार के तहत using TraitName के साथ जोड़े गए extends trait TraitName बनाने के बारे में सोच रहे थे?

यही मेरा विचार है। मेरा मानना ​​​​है कि यह काफी आसान है और कोड पुन: उपयोग के लिए सभी उपयोग मामलों को काफी कवर करता है। मैं विशेषता का उपयोग करने वाले वर्ग को विशेषता विधियों को ओवरराइड करने की अनुमति भी दूंगा (यदि संकलन-समय पर करना संभव है)। लक्षण अन्य लक्षणों का भी विस्तार कर सकते हैं।

और क्या आप इसे स्वयं लागू कर रहे होंगे, या इसे प्रत्यायोजित किया जाएगा?

मुझे यह काम किसी और को सौंपने में कोई दिक्कत नहीं होगी जो इस पर निर्भर है। वैसे भी मेरे पास समय की कमी है। लेकिन हमें डिजाइन पर पहले से सहमत होना चाहिए। मैं विवरण के साथ काफी लचीला हूं लेकिन इसे 1) रनटाइम चेक में नहीं लेना चाहिए (मान लीजिए कि जीडीस्क्रिप्ट खुद को उन सामानों के लिए उधार देता है जिन्हें संकलन पर समझना असंभव है), 2) अपेक्षाकृत सरल हो, और 3) बहुत अधिक न जोड़ें संकलन समय।

@vnen इन विचारों को पसंद कर रहा है। क्या आप सोच रहे थे कि आप कैसे कल्पना करते हैं कि एक विशेषता उन वर्गों के लिए स्वत: पूर्णता जैसी चीजें करने में सक्षम होगी, या यह संभव नहीं होगा?

क्या आप सोच रहे थे कि आप कैसे कल्पना करते हैं कि एक विशेषता उन वर्गों के लिए स्वत: पूर्णता जैसी चीजें करने में सक्षम होगी, या यह संभव नहीं होगा?

मेरे विचार में एक विशेषता अनिवार्य रूप से एक "आयात" होगी। यह मानते हुए कि सदस्यों के लिए काम पूरा हो गया है, पूर्णता दिखाने के लिए तुच्छ होना चाहिए।

@vnen मैं कल्पना करता हूं कि आप अनिवार्य रूप से क्लासनोड में trait ध्वज सेट के साथ पार्स करेंगे। और फिर यदि आप using कथन करते हैं, तो यह सभी गुणों/विधियों/संकेतों/स्थिरांक/उपवर्गों को वर्तमान स्क्रिप्ट में मर्ज करने का प्रयास करेगा।

1. यदि कोई विधि टकराती है, तो वर्तमान स्क्रिप्ट का कार्यान्वयन मूल विधि को ओवरराइड कर देगा, जैसे कि यह विरासत में मिली विधि को ओवरराइड कर रहा था।
   
   
   
   • लेकिन अगर बेस क्लास में पहले से ही "विलय" विधि हो तो क्या करें?
   
   
2. यदि कोई गुण, संकेत, और निरंतर ओवरलैप होता है, तो जांचें कि क्या यह एक ही प्रकार/सिग्नल हस्ताक्षर है। यदि कोई बेमेल नहीं है, तो बस इसे संपत्ति/संकेत/स्थिरांक का "विलय" मानें। अन्यथा, उपयोगकर्ता को एक प्रकार/हस्ताक्षर विरोध (एक पार्स त्रुटि) के बारे में सूचित करें।

बुरा विचार? या क्या हमें गैर-विधि संघर्षों को पूरी तरह से मना करना चाहिए? उपवर्गों के बारे में क्या? मुझे लगता है कि हमें उन्हें संघर्ष बनाना चाहिए।

@willnationsdev ध्वनि "हीरे की समस्या" (उर्फ "मौत का घातक हीरा") की तरह, विभिन्न लोकप्रिय प्रोग्रामिंग भाषाओं में पहले से ही लागू विभिन्न समाधानों के साथ एक अच्छी तरह से प्रलेखित अस्पष्टता।

जिससे मुझे याद आती है:
@vnen क्या लक्षण अन्य लक्षणों का विस्तार करने में सक्षम होने जा रहे हैं?

@ जाहद 2602 उन्होंने पहले ही सुझाव दिया था कि एक संभावना के रूप में

लक्षण अन्य लक्षणों का भी विस्तार कर सकते हैं।

@ jahd2602 पर्ल/पायथन समाधानों के आधार पर, ऐसा लगता है कि वे मूल रूप से प्रत्येक वर्ग के लिए सामग्री वाली परतों का "ढेर" बनाते हैं ताकि अंतिम-उपयोग किए गए विशेषता से शीर्ष पर संघर्ष हो, और अन्य संस्करणों को ओवरराइट करें। यह इस परिदृश्य के लिए एक बहुत अच्छा समाधान की तरह लगता है। जब तक आपके या @vnen के पास वैकल्पिक विचार न हों। समाधान जेहद के लिंक किए गए अवलोकन के लिए धन्यवाद।

कुछ प्रश्न।

पहला: हमें किस तरह से यूजिंग स्टेटमेंट का समर्थन करना चाहिए?

मैं सोच रहा हूँ कि using कथन के लिए कुछ स्थिर-मूल्य वाले GDScript की आवश्यकता होनी चाहिए।

using preload("res://my_trait.gd") # a preloaded expression
using ScriptClass.MyTrait # a const resource
using Autoload.MyTrait # a const resource
using MyTrait # a regular script class

मैं उपरोक्त सभी सोच रहा हूँ।

दूसरा: किसी विशेषता और/या उसके नाम को परिभाषित करने के लिए अनुमत सिंटैक्स क्या होना चाहिए?

हो सकता है कि कोई व्यक्ति अपनी विशेषता के लिए स्क्रिप्ट क्लास का उपयोग करना न चाहे, इसलिए मुझे नहीं लगता कि हमें trait TraitName आवश्यकता को लागू करना चाहिए। मैं सोच रहा हूँ कि trait एक लाइन पर होना चाहिए।

इसलिए, यदि यह एक टूल स्क्रिप्ट है, तो निश्चित रूप से इसमें सबसे ऊपर टूल होना चाहिए। फिर, यदि यह एक विशेषता है, तो इसे परिभाषित करना होगा कि क्या यह निम्न पंक्ति पर एक विशेषता है। वैकल्पिक रूप से किसी को उसी पंक्ति पर विशेषता घोषणा के बाद स्क्रिप्ट वर्ग का नाम बताने की अनुमति दें और यदि वे ऐसा करते हैं, तो उन्हें class_name का उपयोग करने की अनुमति न दें। यदि वे विशेषता नाम छोड़ देते हैं, तो class_name <name> ठीक है। फिर, किसी अन्य प्रकार का विस्तार करते समय, हम विशेषता घोषणा के बाद extends और/या विशेषता घोषणा के बाद स्वयं की एक पंक्ति में सम्मिलित कर सकते हैं। इसलिए, मैं इनमें से प्रत्येक को मान्य मानूंगा:

# Global name from trait keyword.
trait MyTrait extends BaseTrait

# Global name from class_name keyword, but is still a trait and also happens to be a tool script.
tool
trait
extends BaseTrait
class_name MyTrait

# A trait with no global name associated with it. Does not extend anything.
trait

तीसरा: क्या हमें स्वत: पूर्णता उद्देश्यों और/या इरादे/आवश्यकताओं की घोषणा के लिए, एक विशेषता को आधार प्रकार को परिभाषित करने की अनुमति देनी चाहिए जिसे इसे विस्तारित करना चाहिए?

हम पहले ही चर्चा कर चुके हैं कि लक्षणों को अन्य लक्षणों को प्राप्त करने में सहायता करनी चाहिए। लेकिन क्या हमें एक TraitA को extend Node की अनुमति देनी चाहिए, TraitA स्क्रिप्ट को नोड स्वतः पूर्णता प्राप्त करने की अनुमति दें, लेकिन फिर एक पार्स त्रुटि भी ट्रिगर करें यदि हम using TraitA स्टेटमेंट करते हैं जब वर्तमान वर्ग नोड का विस्तार नहीं करता है या इसके किसी भी व्युत्पन्न प्रकार?

चौथा: लक्षण होने के बजाय अन्य लक्षणों का विस्तार करने के बजाय, क्या हम इसके बजाय केवल extends स्टेटमेंट को क्लास एक्सटेंशन के लिए आरक्षित नहीं रख सकते हैं, एक विशेषता को इस कथन की बिल्कुल भी आवश्यकता नहीं है, बल्कि एक आधार विशेषता का विस्तार करने की अनुमति दें लक्षण बस अपने स्वयं के using बयान हैं जो उन लक्षणों को उप-आयात करते हैं?

# base_trait.gd
trait
func my_method():
    print("Hello")

# derived_trait.gd
trait
using preload("base_trait.gd")
func my_method():
   print("World") # overrides previous method, will only print "World".

बेशक, यहां लाभ यह होगा कि आप कई using बयानों का उपयोग करके एक ही विशेषता नाम के तहत कई लक्षणों को बैचने में सक्षम होंगे, सी ++ के समान फाइलें शामिल हैं जिनमें कई अन्य वर्ग शामिल हैं।

पांचवां: यदि हमारे पास एक विशेषता है, और इसमें एक विधि के लिए using या extends है, और फिर स्वयं को लागू करता है, तो उस फ़ंक्शन के भीतर, जब हम कॉल करते हैं तो हम क्या करते हैं .<method_name> आधार कार्यान्वयन निष्पादित करने के लिए? क्या हम मानते हैं कि ये कॉल हमेशा वर्ग विरासत के संदर्भ में निष्पादित होती हैं, और विशेषता पदानुक्रम का यहां कोई प्रभाव नहीं पड़ता है?

cc @vnen

पहला: हमें किस तरह से यूजिंग स्टेटमेंट का समर्थन करना चाहिए?

मैं सोच रहा हूँ कि using कथन के लिए कुछ स्थिर-मूल्य वाले GDScript की आवश्यकता होनी चाहिए।

using preload("res://my_trait.gd") # a preloaded expression
using ScriptClass.MyTrait # a const resource
using Autoload.MyTrait # a const resource
using MyTrait # a regular script class

मैं उन सभी के साथ ठीक हूं। लेकिन पथ के लिए मैं सीधे एक स्ट्रिंग का उपयोग करता हूं: using "res://my_trait.gd"

दूसरा: किसी विशेषता और/या उसके नाम को परिभाषित करने के लिए अनुमत सिंटैक्स को हमें क्या कहना चाहिए?

हो सकता है कि कोई व्यक्ति अपनी विशेषता के लिए स्क्रिप्ट क्लास का उपयोग करना न चाहे, इसलिए मुझे नहीं लगता कि हमें trait TraitName आवश्यकता को लागू करना चाहिए। मैं सोच रहा हूँ कि trait एक लाइन पर होना चाहिए।

इसलिए, यदि यह एक टूल स्क्रिप्ट है, तो निश्चित रूप से इसमें सबसे ऊपर टूल होना चाहिए। फिर, यदि यह एक विशेषता है, तो इसे परिभाषित करना होगा कि क्या यह निम्न पंक्ति पर एक विशेषता है। वैकल्पिक रूप से किसी को उसी पंक्ति पर विशेषता घोषणा के बाद स्क्रिप्ट वर्ग का नाम बताने की अनुमति दें और यदि वे ऐसा करते हैं, तो उन्हें class_name का उपयोग करने की अनुमति न दें। यदि वे विशेषता नाम छोड़ देते हैं, तो class_name <name> ठीक है। फिर, किसी अन्य प्रकार का विस्तार करते समय, हम विशेषता घोषणा के बाद extends और/या विशेषता घोषणा के बाद स्वयं की एक पंक्ति में सम्मिलित कर सकते हैं। इसलिए, मैं इनमें से प्रत्येक को मान्य मानूंगा:

# Global name from trait keyword.
trait MyTrait extends BaseTrait

# Global name from class_name keyword, but is still a trait and also happens to be a tool script.
tool
trait
extends BaseTrait
class_name MyTrait

# A trait with no global name associated with it. Does not extend anything.
trait

tool किसी विशेषता पर कोई फर्क नहीं पड़ना चाहिए, क्योंकि वे सीधे निष्पादित नहीं होते हैं।

मैं सहमत हूं कि एक विशेषता का वैश्विक नाम होना जरूरी नहीं है। मैं trait का उपयोग trait tool समान तरीके से करूंगा। स्क्रिप्ट फ़ाइल में यह पहली चीज़ होनी चाहिए (टिप्पणियों को छोड़कर)। कीवर्ड को वैकल्पिक रूप से विशेषता नाम के बाद किया जाना चाहिए। मैं उनके लिए class_name का उपयोग नहीं करूंगा, क्योंकि वे कक्षाएं नहीं हैं।

तीसरा: क्या हमें स्वत: पूर्णता उद्देश्यों और/या इरादे/आवश्यकताओं की घोषणा के लिए, एक विशेषता को आधार प्रकार को परिभाषित करने की अनुमति देनी चाहिए जिसे इसे विस्तारित करना चाहिए?

मैं ईमानदारी से संपादक की खातिर भाषा में सुविधाओं को जोड़ना पसंद नहीं करता। यहीं पर एनोटेशन काम आएंगे।

अब अगर हम लक्षणों को केवल एक निश्चित प्रकार (और उसके डेरिवेटिव) पर लागू करना चाहते हैं, तो यह ठीक है। वास्तव में, मुझे लगता है कि यह स्थिर जांच के लिए बेहतर है: यह एक वर्ग से सामान का उपयोग करने की अनुमति देता है जबकि संकलन वास्तव में जांच सकता है कि उनका उपयोग सही प्रकारों और क्या नहीं के साथ किया जा रहा है।

चौथा: लक्षण होने के बजाय अन्य लक्षणों का विस्तार करने के बजाय, क्या हम इसके बजाय केवल extends स्टेटमेंट को क्लास एक्सटेंशन के लिए आरक्षित नहीं रख सकते हैं, एक विशेषता को इस कथन की बिल्कुल भी आवश्यकता नहीं है, बल्कि एक आधार विशेषता का विस्तार करने की अनुमति दें लक्षण के लिए बस अपने स्वयं के using बयान हैं जो उप-आयात _those_ लक्षण हैं?

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

पांचवां: यदि हमारे पास एक विशेषता है, और इसमें एक विधि के लिए using या extends है, और फिर स्वयं को लागू करता है, तो उस फ़ंक्शन के भीतर, जब हम कॉल करते हैं तो हम क्या करते हैं .<method_name> आधार कार्यान्वयन निष्पादित करने के लिए? क्या हम मानते हैं कि ये कॉल हमेशा वर्ग विरासत के संदर्भ में निष्पादित होती हैं, और विशेषता पदानुक्रम का यहां कोई प्रभाव नहीं पड़ता है?

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

ओटीओएच, एक विशेषता लगभग "शामिल" की तरह है, इसलिए इसे कक्षा में शब्दशः लागू किया जाएगा, इसलिए मूल कार्यान्वयन को कॉल किया जाएगा। लेकिन अगर मूल विशेषता में विधि नहीं मिलती है तो ईमानदारी से मैं डॉट नोटेशन को मना कर दूंगा।

उस विशेषता के बारे में क्या है जिसके लिए कक्षा में एक या अधिक अन्य लक्षणों की आवश्यकता होती है? उदाहरण के लिए, एक विशेषता DoubleJumper जिसके लिए विशेषता Jumper , एक विशेषता Upgradable और एक वर्ग जो विरासत में मिला है KinematicBody2D ।

उदाहरण के लिए, जंग आपको उन जैसे प्रकार के हस्ताक्षरों का उपयोग करने की अनुमति देता है। KinematicBody2D: Jumper, Upgradable जैसा कुछ। लेकिन चूंकि हम टाइप को एनोटेट करने के लिए : का उपयोग कर रहे हैं, हम केवल KinematicBody2D & Jumper & Upgradable या कुछ और का उपयोग कर सकते हैं।

बहुरूपता मुद्दा भी है। क्या होगा यदि प्रत्येक वर्ग के लिए विशेषता का कार्यान्वयन अलग है, लेकिन यह एक ही इंटरफ़ेस को उजागर करता है?

उदाहरण के लिए, हम kill() विशेषता Jumper में एक विधि चाहते हैं, जिसका उपयोग Enemy और Player दोनों द्वारा किया जाता है। हम प्रत्येक मामले के लिए अलग-अलग कार्यान्वयन चाहते हैं, जबकि दोनों को समान Jumper प्रकार के हस्ताक्षर के साथ संगत रखते हुए। यह कैसे करना है?

बहुरूपता के लिए, आप केवल एक अलग विशेषता बनाएंगे जिसमें kill() के साथ विशेषता शामिल है और फिर विधि का अपना विशिष्ट संस्करण लागू करता है। पहले शामिल लक्षणों के तरीकों को ओवरराइड करने वाले लक्षणों का उपयोग करना यह है कि आप इसे कैसे संभालेंगे।

साथ ही, मुझे नहीं लगता कि एक प्रकार के संकेत के लिए कोई योजना (अभी तक) विशेषता की आवश्यकता है। क्या हम ऐसा कुछ करना चाहेंगे?

एक अलग विशेषता बनाएँ

क्या यह एकबारगी विशेषता फ़ाइलों का एक गुच्छा उत्पन्न नहीं करेगा? यदि हम नेस्टेड विशेषता घोषणाएं ( class कीवर्ड के समान) कर सकते हैं, तो यह अधिक सुविधाजनक हो सकता है। हम उस वर्ग में सीधे विधियों को ओवरराइड भी कर सकते हैं जो विशेषता का उपयोग कर रहे हैं।

मैं वास्तव में एक मजबूत प्रकार की हस्ताक्षर प्रणाली (शायद बूलियन रचना और वैकल्पिक/गैर-नल के साथ) की सराहना करता हूं। लक्षण सही में फिट होंगे।

मुझे यकीन नहीं है कि इस पर चर्चा की गई थी, लेकिन मुझे लगता है कि किसी फ़ंक्शन के विशेषता विशिष्ट संस्करण को लागू करना संभव होना चाहिए। उदाहरण के लिए:

trait A
func m():
  print("A")

trait B
func m():
  print("B")

class C
using A
using B

func c():
  A.m()
  B.m()
  m()

जो प्रिंट करता है: A , B , B ।

इसके अलावा, मैं "नो रनटाइम कॉस्ट" के बारे में पूरी तरह से निश्चित नहीं हूं। निर्यात से पहले परिभाषित किए गए लक्षणों का उपयोग कर रहे वर्गों के साथ गतिशील रूप से लोड की गई स्क्रिप्ट (निर्यात के दौरान उपलब्ध नहीं) को कैसे संभाला जाएगा? क्या मैं कुछ गलत समझ रहा हूँ? या उस मामले को "रनटाइम" नहीं माना जाता है?

मुझे यकीन नहीं है कि इस पर चर्चा की गई थी, लेकिन मुझे लगता है कि किसी फ़ंक्शन के विशेषता विशिष्ट संस्करण को लागू करना संभव होना चाहिए।

मैं पहले से ही इस पर विचार कर रहा था, लेकिन मैं एक वर्ग को परस्पर विरोधी लक्षणों का उपयोग करने की अनुमति देने के बारे में निश्चित नहीं हूं (अर्थात, ऐसे लक्षण जो समान नाम से विधि को परिभाषित करते हैं)। using बयानों के क्रम से कोई फर्क नहीं पड़ना चाहिए।

इसके अलावा, मैं "नो रनटाइम कॉस्ट" के बारे में पूरी तरह से निश्चित नहीं हूं। निर्यात से पहले परिभाषित किए गए लक्षणों का उपयोग कर रहे वर्गों के साथ गतिशील रूप से लोड की गई स्क्रिप्ट (निर्यात के दौरान उपलब्ध नहीं) को कैसे संभाला जाएगा? क्या मैं कुछ गलत समझ रहा हूँ? या उस मामले को "रनटाइम" नहीं माना जाता है?

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

सभी को नमस्कार।

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

इस काम को करने के लिए रूट नोड को गुणों को "निर्यात" करना होगा और फिर मानों को उपयुक्त बच्चे को _ready में कॉपी करना होगा। इसलिए, उदाहरण के लिए, एक बच्चे टाइमर के साथ एक बम नोड की कल्पना करें। उप-दृश्य में रूट बम नोड "detonation_time" निर्यात करेगा और फिर यह _ready में $Timer.wait_time = detonation_time करेगा। यह हमें गोदोट के UI में इसे अच्छी तरह से सेट करने की अनुमति देता है जब भी हम इसे बच्चों को संपादन योग्य बनाने और टाइमर तक ड्रिल किए बिना इसका उदाहरण देते हैं।

हालाँकि
1) यह एक बहुत ही यांत्रिक परिवर्तन है इसलिए ऐसा लगता है कि सिस्टम द्वारा कुछ इसी तरह का समर्थन किया जा सकता है
2) यह शायद सीधे बच्चे के नोड में उचित मान सेट करने में थोड़ी सी अक्षमता जोड़ता है।

इससे पहले कि मैं आगे बढ़ूं, यह चर्चा की जा रही बातों के लिए स्पर्शरेखा प्रतीत हो सकता है क्योंकि इसमें "निजी" विरासत (सी ++ भाषा में) की अनुमति शामिल नहीं है। हालांकि, मुझे वास्तव में अधिक विरासत जैसी इंजीनियरिंग के बजाय दृश्य तत्वों की रचना करके व्यवहार के निर्माण की गोडोट की प्रणाली पसंद है। वे "लिखित" संबंध अपरिवर्तनीय और स्थिर हैं। ओटीओएच, दृश्य संरचना गतिशील है, आप इसे रन टाइम पर भी बदल सकते हैं। खेल तर्क विकास के दौरान परिवर्तन के अधीन इतना अधिक है कि मुझे लगता है कि गोडोट का डिज़ाइन उपयोग के मामले में बहुत अच्छी तरह से फिट बैठता है।

यह सच है कि चाइल्ड नोड्स का उपयोग रूट नोड्स के व्यवहार विस्तार के रूप में किया जाता है, लेकिन इससे उनमें आत्मनिर्भरता, IMO की कमी नहीं होती है। एक टाइमर पूरी तरह से स्व-निहित और व्यवहार में अनुमानित है, चाहे वह समय के लिए उपयोग किया गया हो। चाहे आप सूप पीने के लिए चम्मच का उपयोग करें या आइसक्रीम खाने के लिए, यह उपयुक्त रूप से अपना कार्य करता है, भले ही यह आपके हाथ के विस्तार के रूप में कार्य कर रहा हो। मैं रूट नोड्स को उस्ताद के रूप में देखता हूं जो चाइल्ड नोड्स के व्यवहार का समन्वय करते हैं ताकि उन्हें सीधे एक-दूसरे के बारे में जानने की जरूरत न पड़े और इसलिए वे आत्म-निहित रहने में सक्षम हैं। माता-पिता/रूट नोड्स डेस्क-बाउंड मैनेजर हैं जो जिम्मेदारियों को सौंपते हैं लेकिन ज्यादा सीधा काम नहीं करते हैं। चूंकि वे पतले हैं, इसलिए थोड़ा अलग व्यवहार के लिए एक नया बनाना आसान है।

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

एक चीज जिसके बारे में मैं सोच रहा हूं वह है "डायनेमिक इनहेरिटेंस" की एक प्रणाली, यदि आप चाहें, तो Node. इस तरह की स्क्रिप्ट में गुणों/विधियों के दो स्रोत होंगे, एक स्क्रिप्ट जो इसे विस्तारित करती है और वे जो दृश्य संरचना के भीतर बच्चों से "बुलबुले" होते हैं। तो बम के साथ मेरा उदाहरण कुछ इस तरह बन जाएगा export lifted var $Timer.wait_time [= value?] as detonation_time Bomb.gd स्क्रिप्ट के सदस्य चर अनुभाग के भीतर। सिस्टम अनिवार्य रूप से _ready कॉलबैक में $Timer.wait_time = detonation_time उत्पन्न करेगा और गेटर/सेटर उत्पन्न करेगा जो बम नोड के माता-पिता से $Bomb.detonation_time = 5 की अनुमति देगा जिसके परिणामस्वरूप $Timer.wait_time = 5 सेट किया जा रहा है।

ओपी के उदाहरण में MoveRightTrait के साथ हमारे पास वह नोड होगा जिससे mysprite.gd संलग्न है, MoveRightTrait चाइल्ड नोड के रूप में है। फिर mysprite.gd में हमारे पास lifted func $MoveRightTrait.move_right [as move_right] जैसा कुछ होगा (शायद 'as' वैकल्पिक हो सकता है जब नाम वही होगा)। अब mysprite.gd से बनाई गई स्क्रिप्ट ऑब्जेक्ट पर move_right को कॉल करना स्वचालित रूप से उपयुक्त चाइल्ड नोड को सौंप देगा। शायद संकेतों को बुदबुदाया जा सकता है ताकि उन्हें जड़ से एक बच्चे के नोड से जोड़ा जा सके? शायद पूरे नोड्स को func, सिग्नल या var के बिना केवल lifted $MoveRightTrait [as MvR] के साथ बुलबुला किया जा सकता है। इस मामले में MoveRightTrait पर सभी विधियों और गुणों को mysprite से सीधे mysprite.move_right के रूप में या mysprite.MvR.move_right के माध्यम से एक्सेस किया जा सकता है यदि 'as MvR' का उपयोग किया जाता है।

यह एक विचार है कि कैसे एक इंस्टेंस्ड शाखा की जड़ में एक दृश्य संरचना के लिए एक इंटरफ़ेस के निर्माण को सरल बनाया जाए, उनकी "ब्लैक बॉक्स" विशेषता को बढ़ाया जाए और गोडोट की गतिशील दृश्य प्रणाली की शक्ति के साथ-साथ स्क्रिप्टिंग सुविधा प्राप्त की जाए। बेशक, विचार करने के लिए कई पक्ष विवरण होंगे। उदाहरण के लिए, बेस क्लास के विपरीत चाइल्ड नोड्स को रन टाइम पर हटाया जा सकता है। बुलबुले/उठाए गए कार्यों और गुणों को उस त्रुटि मामले में कॉल/एक्सेस किए जाने पर कैसे व्यवहार करना चाहिए? यदि सही नोडपाथ वाला नोड वापस जोड़ा जाता है तो क्या उठाए गए गुण फिर से काम करना शुरू कर देते हैं? [हां, आईएमओ] इसके अलावा नोड से व्युत्पन्न कक्षाओं में 'उठाया' का उपयोग करने में त्रुटि होगी क्योंकि उस मामले में बच्चों को बुलबुला/लिफ्ट करने के लिए कभी भी नहीं होगा। इसके अलावा, डुप्लिकेट "जैसा {name}" या "लिफ़्टेड $Timer1 लिफ्टेड $Timer2" के साथ नाम का टकराव संभव है, जहां नोड्स में एक ही नाम के गुण/विधियां हैं। स्क्रिप्ट दुभाषिया आदर्श रूप से ऐसी तार्किक समस्याओं का पता लगाएगा।

मुझे ऐसा लगता है कि यह हमें वह बहुत कुछ देगा जो हम चाहते हैं, भले ही यह वास्तव में केवल वाक्य रचनात्मक चीनी है जो हमें अग्रेषण कार्यों और प्रारंभिकताओं को लिखने से बचाती है। साथ ही, क्योंकि यह मूल रूप से अवधारणात्मक रूप से सरल है, इसे लागू करना या व्याख्या करना इतना कठिन नहीं होना चाहिए।

वैसे भी, अगर आपको इतना मिल गया है तो पढ़ने के लिए धन्यवाद!

मैंने हर जगह "उठाया" इस्तेमाल किया लेकिन यह सिर्फ उदाहरण है।
using var $Timer.wait_time as detonation_time या using $Timer जैसा कुछ स्पष्ट रूप से उतना ही अच्छा है। किसी भी मामले में आप आसानी से चाइल्ड नोड्स से छद्म-विरासत प्राप्त करते हैं, जिससे शाखा की जड़ में वांछित कार्यक्षमता तक पहुंच का एक सुसंगत एकल बिंदु बनता है। कार्यक्षमता के पुन: प्रयोज्य टुकड़ों की आवश्यकता यह है कि वे नोड या इसके उपवर्ग का विस्तार करें ताकि उन्हें बड़े घटक में बच्चों के रूप में जोड़ा जा सके।

इसे देखने का एक और तरीका यह है कि एक नोड से विरासत में मिली स्क्रिप्ट पर "विस्तारित" कीवर्ड आपको "बबल अप" करने के लिए एक स्क्रिप्ट पर "उपयोग" या "उठाया" कीवर्ड का उपयोग करते समय आपका "इस-ए" संबंध देता है। वंशज नोड के सदस्य आपको "कार्यान्वयन" [हे, संभावित कीवर्ड] के समान कुछ देते हैं जो एकल विरासत वाली भाषाओं में मौजूद है लेकिन एकाधिक "इंटरफेस" (उदाहरण के लिए जावा)। अप्रतिबंधित एकाधिक विरासत (जैसे सी ++) में बेस क्लास एक [स्थैतिक, लिखित-इन] पेड़ बनाते हैं। सादृश्य से मैं गोडोट के मौजूदा नोड पेड़ों पर सुविधाजनक सिंटैक्स और बॉयलरप्लेट उन्मूलन का प्रस्ताव कर रहा हूं।

यदि यह कभी निर्धारित किया जाता है कि यह खोज के लायक कुछ है, तो विचार करने के लिए डिज़ाइन स्थान के पहलू हैं:
1) क्या हमें केवल तत्काल बच्चों को "उपयोग" में अनुमति देनी चाहिए। IOW using $Timer लेकिन नहीं using $Bomb/Timer'? This would be simpler but would force us to write boilerplate in some cases. I say that a full NodePath ROOTED in the Node to which the script is attached should be legal [but NO references to parents/siblings allowed]. 2) Should there be an option that find_node के the "using"-ed node instead of following a written in NodePath? For example "टाइमर" का उपयोग करके with a string for the pattern would be slower but the forwarding architecture would continue to work if a referenced node's position in the sub-tree changes at run time. This could be used selectively for child nodes that we expect to move around beneath the root. Of course syntax would have to be worked out especially when using a particular member (eg. var "Timer" का उपयोग करते हुए। डेटोनेशन_टाइम के रूप में प्रतीक्षा_टाइम is icky). 3) Should there be a way query for certain functionality [equivalent to asking if an interface is implemented or a child node is present]? Perhaps "using" entire nodes with aliases should allow testing the alias to be a query. So MoveRightTrait का उपयोग करके डायरेक्शनलमूवर in a script would result in नोड.डायरेक्शनलमोवर returning the child MoveRightTrait. This is logical because नोड.DirectionalMover.move_right() calls the method on the child MoveRightTrait. Other nodes without that statement would return null. So the statement अगर node.DirectionalMover:` कन्वेंशन द्वारा कार्यक्षमता के लिए एक परीक्षण बन जाएगा।
4) स्टेट पैटर्न को "उपयोग"-एड नोड को दूसरे के साथ बदलकर लागू किया जाना चाहिए जिसमें भिन्न व्यवहार है लेकिन एक ही इंटरफ़ेस [बतख टाइपिंग] और उसी नोडपाथ जैसा कि "उपयोग" कथन में संदर्भित है। जिस तरह से सीन ट्री काम करता है, वह लगभग मुफ्त में काम करेगा। हालांकि, सिस्टम को माता-पिता के माध्यम से जुड़े संकेतों को ट्रैक करना होगा और बदले गए बच्चे में कनेक्शन बहाल करना होगा।

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

या केवल घटकों को अनुकरण करने के लिए पेड़ के स्तरों को जोड़ना (यह काफी बोझिल हो जाता है, क्योंकि तब आप प्रत्येक नए घटक के साथ सभी नोड पथ तोड़ते हैं)। हो सकता है कि कोई बेहतर तरीका हो, मेटा/मल्टी स्क्रिप्ट जैसा कुछ एक नोड पर एकाधिक स्क्रिप्ट की इजाजत देता है? यदि आपके पास मुहावरेदार समाधान है, तो कृपया साझा करें ...

C++ (GDNative) को मिक्स में फेंकने से चीजें और भी खराब हो जाती हैं, क्योंकि _ready और _init वहां अलग-अलग व्यवहार करते हैं (पढ़ें: डिफ़ॉल्ट मानों के साथ इनिशियलाइज़ेशन आधा काम करता है या बिल्कुल भी काम नहीं करता है)।

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

वर्तमान में मैं इन साझा 'घटकों' को उन 'इकाइयों' में लोड किए गए वर्गों या नोड्स के रूप में कार्यान्वित करता हूं जिनकी उन्हें आवश्यकता होती है, लेकिन यह गन्दा है (नोड्स के लिए बहुत सारी खोजें जोड़ता है, बतख-टाइपिंग को लगभग असंभव बना देता है, आदि) और वैकल्पिक दृष्टिकोणों की अपनी कमियां हैं इसलिए मुझे कोई बेहतर तरीका नहीं मिला। लक्षण/मिश्रण पूरी तरह से मेरे जीवन को बचाएंगे।

यह जो नीचे आता है वह विरासत का उपयोग किए बिना वस्तुओं में कोड साझा करने में सक्षम है, जो मुझे लगता है कि गोडोट में अभी सफाई से करना आवश्यक और संभव नहीं है।

जिस तरह से मैं जंग के लक्षणों को समझता हूं (https://doc.rust-lang.org/1.8.0/book/traits.html), यह है कि वे हास्केल टाइपक्लास की तरह हैं, जहां आपको प्रकार के लिए परिभाषित करने के लिए कुछ पैरामीटरयुक्त कार्यों की आवश्यकता होती है आप इसमें एक विशेषता जोड़ रहे हैं, और फिर आप किसी भी प्रकार से परिभाषित कुछ सामान्य कार्यों का उपयोग कर सकते हैं जो एक विशेषता को लागू करते हैं। क्या जंग के लक्षण यहां प्रस्तावित से कुछ अलग हैं?

https://github.com/godotengine/godot-proposals/

यह संभवतः थोक माइग्रेट किया जाएगा, क्योंकि इसकी यहां व्यापक चर्चा हुई है।

यह संभवतः थोक माइग्रेट किया जाएगा, क्योंकि इसकी यहां व्यापक चर्चा हुई है।

_मुझे प्रस्तावों का "चलना" व्यर्थ लगता है, वे बेहतर बंद हैं और अगर लोग रुचि व्यक्त करते हैं तो उन्हें गोडोट-प्रस्तावों में फिर से खोलने के लिए कहा जाता है, और यदि आवश्यक हो तो अन्य प्रस्तावों को वास्तव में लागू करने दें। वैसे भी..._

मैं एक साल पहले इस मुद्दे पर ठोकर खाई थी, लेकिन अब मैं विशेषता प्रणाली की संभावित उपयोगिता को समझना शुरू कर देता हूं।

किसी को समस्या को बेहतर ढंग से समझने के लिए प्रेरित करने की उम्मीद में मेरे वर्तमान कार्यप्रवाह को साझा करना (और शायद लक्षण प्रणाली को लागू करने के अलावा एक बेहतर विकल्प का सुझाव देना)।

1. प्रोजेक्ट में उपयोग किए गए प्रत्येक नोड प्रकार के लिए घटक टेम्पलेट जेनरेट करने के लिए एक टूल बनाएं:

@willnationsdev https://github.com/godotengine/godot/issues/23101#issuecomment -431468744

अब, जो इसे आसान बना देगा वह होगा एक स्निपेट सिस्टम या मैक्रो सिस्टम ताकि डेवलपर्स के लिए उन पुन: उपयोग किए गए घोषणात्मक कोड अनुभागों को बनाना आसान हो।

आपके पदचिन्हों पर चलना...

tool
extends EditorScript

const TYPES = [
    'Node',
    'Node2D',
]
const TYPES_PATH = 'types'
const TYPE_BASENAME_TEMPLATE = 'component_%s.gd'

const TEMPLATE = \
"""class_name Component{TYPE} extends {TYPE}

signal host_assigned(node)

export(bool) var enabled = true

export(NodePath) var host_path
var host

func _ready():
    ComponentCommon.init(self, host_path)"""

func _run():
    _update_scripts()


func _update_scripts():

    var base_dir = get_script().resource_path.get_base_dir()
    var dest = base_dir.plus_file(TYPES_PATH)

    for type in TYPES:
        var filename = TYPE_BASENAME_TEMPLATE % [type.to_lower()]
        var code = TEMPLATE.format({"TYPE" : type})
        var path = dest.plus_file(filename)

        print_debug("Writing component code for: " + path)

        var file = File.new()
        file.open(path, File.WRITE)
        file.store_line(code)
        file.close()

2. होस्ट करने के लिए घटकों को प्रारंभ करने के लिए पुन: उपयोग करने के लिए एक स्थिर विधि बनाएं (उदाहरण के लिए रूट):

class_name ComponentCommon

static func init(p_component, p_host_path = NodePath()):

    assert(p_component is Node)

    # Try to assign
    if not p_host_path.is_empty():
        p_component.host = p_component.get_node(p_host_path)

    elif is_instance_valid(p_component.owner):
        p_component.host = p_component.owner

    elif is_instance_valid(p_component.get_parent()):
        p_component.host = p_component.get_parent()

    # Check
    if not is_instance_valid(p_component.host):
        push_warning(p_component.name.capitalize() + ": couldn't find a host, disabling.")
        p_component.enabled = false
    else:
        p_component.emit_signal('host_assigned')

पहली स्क्रिप्ट के साथ उत्पन्न होने पर एक घटक (विशेषता) इस तरह दिखता है:

class_name ComponentNode2D extends Node2D

signal host_assigned(node)

export(bool) var enabled = true

export(NodePath) var host_path
var host

func _ready():
    ComponentCommon.init(self, host_path)

(वैकल्पिक) 3. घटक बढ़ाएँ (लक्षण)

@vnen https://github.com/godotengine/godot/issues/23101#issuecomment -471816901

यही मेरा विचार है। मेरा मानना ​​​​है कि यह काफी आसान है और कोड पुन: उपयोग के लिए सभी उपयोग मामलों को काफी कवर करता है। मैं विशेषता का उपयोग करने वाले वर्ग को विशेषता विधियों को ओवरराइड करने की अनुमति भी दूंगा (यदि संकलन-समय पर करना संभव है)। लक्षण अन्य लक्षणों का भी विस्तार कर सकते हैं।

आपके पदचिन्हों पर चलना...

class_name ComponentMotion2D extends ComponentNode2D

const MAX_SPEED = 100.0

var linear_velocity = Vector2()
var collision

export(Script) var impl
...

वास्तव में, निर्यात किए गए Script s का उपयोग इन घटकों में प्रति घटक विशिष्ट होस्ट/रूट नोड प्रकारों के व्यवहार को चलाने के लिए किया जाता है। यहां, ComponentMotion2D में मुख्य रूप से दो स्क्रिप्ट होंगी:

• motion_kinematic_body_2d.gd
• motion_rigid_body_2d.gd

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

घटक स्वयं को onready सदस्य बनाकर जड़ में "हार्डवार्ड" कर रहे हैं, प्रभावी रूप से बॉयलरप्लेट कोड को कम कर रहे हैं (वास्तव में उन्हें object.motion के रूप में संदर्भित करने के खर्च के साथ)

extends KinematicBody2D

onready var motion = $motion # ComponentMotion2D

सुनिश्चित नहीं है कि यह समस्या को हल करने में मदद करेगा, लेकिन सी # में विस्तार विधियों नामक एक चीज है जो कक्षा प्रकार की कार्यक्षमता को बढ़ाती है।

मूल रूप से फ़ंक्शन स्थिर होना चाहिए, और पहला पैरामीटर आवश्यक है और self होना चाहिए। यह इस तरह एक परिभाषा के रूप में दिखेगा:

एक्सटेंशन.जीडी

# any script that uses this method must be an instance of `Node2D`
static func distance(self source: Node2D, target: Node2D):
    return source.global_position.distance_to(target.global_position)

# any script that uses this method must be an instance of `Rigidbody2D`
# a `Sprite` instance cannot use this method
static func distance(self source: Rigidbody2D, target: Node2D):
    return source.global_position.distance_to(target.global_position)

फिर जब आप distance विधि का उपयोग करना चाहते हैं, तो आप बस यह करें:

खिलाड़ी.जीडी

func _ready() -> void:
    print(self.distance($Enemy))
    print($BulletPoint.distance($Enemy))

मैं इससे परिचित हूं, लेकिन इससे समस्या का समाधान नहीं होता है। हे, हालांकि धन्यवाद।

@TheColorRed विस्तार विधियां पहले से ही प्रस्तावित थीं, लेकिन मुझे नहीं लगता कि वे गतिशील भाषा में व्यवहार्य हैं। मुझे यह भी नहीं लगता कि वे मूल समस्या का समाधान करते हैं जिसने शुरुआत में इस चर्चा को शुरू किया था।

एक और नोट पर, मैं शायद जीडीस्क्रिप्ट के लिए जीआईपी के रूप में कई प्रस्ताव खोलूंगा (इसमें शामिल है, अगर @willnationsdev बुरा न मानें)।

मुझे अभी भी विश्वास है कि लक्षण एक ओओ भाषा में क्षैतिज रूप से कोड साझा करने के लिए सबसे अधिक समझ में आता है (एकाधिक विरासत के बिना, लेकिन मैं उस तरह से नहीं जाना चाहता)।

मुझे नहीं लगता कि वे गतिशील भाषा में संभव हैं

हालांकि जीडीएस गतिशील है? विस्तार विधियां केवल टाइप किए गए उदाहरणों तक ही सीमित हो सकती हैं और अन्य भाषाओं की तरह ही काम करेंगी - संकलन के दौरान केवल एक वाक्य रचनात्मक चीनी स्थिर विधि (फ़ंक्शन) कॉल के साथ विधि कॉल को प्रतिस्थापित करती है। ईमानदारी से, मैं प्रोटोटाइप अला जेएस या कक्षाओं या यहां तक ​​​​कि सिर्फ उदाहरणों के तरीकों को जोड़ने के अन्य गतिशील तरीकों से पहले pimps (ext। विधियों) को प्राथमिकता दूंगा।

हम जो कुछ भी करने का फैसला करते हैं, मुझे उम्मीद है कि हम इसे "पिंप्स" नाम देने का फैसला नहीं करेंगे।

हालांकि जीडीएस गतिशील है?

इस संदर्भ में "गतिशील" की बहुत सारी परिभाषाएँ हैं। स्पष्ट होने के लिए: परिवर्तनीय प्रकार संकलन समय पर ज्ञात नहीं हो सकता है, इसलिए विधि विस्तार जांच को रनटाइम पर किया जाना चाहिए (जो प्रदर्शन को एक तरफ या किसी अन्य को नुकसान पहुंचाएगा)।

विस्तार विधियां केवल टाइप किए गए उदाहरणों तक ही सीमित हो सकती हैं

अगर हम ऐसा करना शुरू करते हैं तो हम केवल GDScript टाइप कर सकते हैं। लेकिन यह एक पूरी तरह से अन्य चर्चा है कि मुझे यहां नहीं जाना है।

बिंदु यह है: चीजों को काम करना शुरू या बंद नहीं करना चाहिए क्योंकि उपयोगकर्ता ने स्क्रिप्ट में प्रकार जोड़े हैं। ऐसा होने पर यह लगभग हमेशा भ्रमित करने वाला होता है।

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

ईमानदारी से, मैं प्रोटोटाइप अला जेएस या कक्षाओं या यहां तक ​​​​कि सिर्फ उदाहरणों के तरीकों को जोड़ने के अन्य गतिशील तरीकों से पहले pimps (ext। विधियों) को प्राथमिकता दूंगा।

किसी ने भी प्रस्तावित (अभी तक) विधियों को गतिशील रूप से (रनटाइम पर) संलग्न करने का प्रस्ताव नहीं दिया है और मुझे वह भी नहीं चाहिए। संकलन समय पर लक्षणों को स्थिर रूप से लागू किया जाएगा।

मैंने मूल रूप से Haxe और इसकी मिश्रित मैक्रो लाइब्रेरी के बारे में एक टिप्पणी की थी, लेकिन तब मुझे एहसास हुआ कि अधिकांश उपयोगकर्ता वैसे भी किसी तृतीय-पक्ष भाषा का उपयोग नहीं करेंगे।

मुझे हाल ही में इसकी आवश्यकता हुई है।

मेरे पास कुछ ऑब्जेक्ट्स हैं जिनके साथ उपयोगकर्ता इंटरैक्ट कर सकता है लेकिन एक ही माता-पिता को साझा नहीं कर सकता है, लेकिन उन्हें एपीआई के समान समूहों की आवश्यकता है

उदाहरण के लिए मेरे पास कुछ वर्ग हैं जो एक ही माता-पिता से प्राप्त नहीं हो सकते हैं, लेकिन एपीआई के समान सेट का उपयोग करें:
वेयरहाउस: वित्त, हटाना, माउस इंटरेक्शन + अन्य
वाहन: वित्त, हटाना, माउस इंटरेक्शन + अन्य
वाहन टर्मिनल: वित्त, हटाना, माउस इंटरेक्शन + अन्य

वित्त के लिए मैंने रचना का उपयोग किया है, क्योंकि इसके लिए कम से कम बॉयलर प्लेट कोड की आवश्यकता होती है क्योंकि get_finances_component() एक पर्याप्त एपीआई है क्योंकि यह वास्तव में गेम ऑब्जेक्ट की बिल्कुल भी परवाह नहीं करता है।

दूसरे:
माउस इंटरेक्शन और डिलेक्शन मुझे सिर्फ कॉपी और पेस्ट करना है क्योंकि इसे गेम ऑब्जेक्ट्स के बारे में जानने की जरूरत है, कुछ रचना यहां काम नहीं करती है जब तक कि मैंने कुछ अजीब प्रतिनिधिमंडल नहीं किया:

Warehouse:
  func delete():
      get_delete_component().delete(self);

लेकिन यह वास्तव में मुझे ओवरराइड करने की अनुमति नहीं देता है कि कैसे हटाएं काम करता है, जहां यह एक विरासत वर्ग था, यदि आवश्यक हो तो मुझे कुछ हटाने कोड को फिर से लिखने की क्षमता हो सकती है।

माउस इंटरेक्शन और डिलेक्शन मुझे बस कॉपी और पेस्ट करना है क्योंकि इसे गेम ऑब्जेक्ट्स के बारे में जानने की जरूरत है, कुछ रचना यहां काम नहीं करती है जब तक कि मैंने कुछ अजीब प्रतिनिधिमंडल नहीं किया

मैं वर्तमान में onready नोड्स के माध्यम से घटकों का उपयोग करता हूं। मैं कुछ ऐसा ही कर रहा हूँ:

# character.gd

var input = $input # input component

func _set(property, value):
    if property == "focused": # override
        input.enabled = value
    return true

तो यह:

character.input.enabled = true

यह बन जाता है:

character.focused = true

जैसा कि @Calinou ने कृपया मेरे मुद्दे की ओर इशारा किया है https://github.com/godotengine/godot-proposals/issues/758 इससे निकटता से संबंधित है। समूह में एक विशेषता जोड़ने में सक्षम होने के प्रस्ताव के बारे में आप क्या सोचते हैं? यह काफी हद तक स्क्रिप्ट और अन्य ओवरहेड की आवश्यकता हो सकती है।

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

गोडोट इंजन के लिए फीचर और सुधार प्रस्तावों पर अब एक समर्पित गोडोट इम्प्रूवमेंट प्रपोजल (जीआईपी) ( godotengine/godot-proposals ) इश्यू ट्रैकर में चर्चा और समीक्षा की जा रही है। जीआईपी ट्रैकर में एक विस्तृत मुद्दा टेम्पलेट डिज़ाइन किया गया है ताकि प्रस्तावों में उत्पादक चर्चा शुरू करने के लिए सभी प्रासंगिक जानकारी शामिल हो और समुदाय को इंजन के प्रस्ताव की वैधता का आकलन करने में सहायता मिल सके।

मुख्य ( godotengine/godot ) ट्रैकर अब पूरी तरह से बग रिपोर्ट और पुल अनुरोधों के लिए समर्पित है, जिससे योगदानकर्ताओं को बग फिक्सिंग कार्य पर बेहतर ध्यान केंद्रित करने में मदद मिलती है। इसलिए, अब हम मुख्य मुद्दे ट्रैकर पर सभी पुराने फीचर प्रस्तावों को बंद कर रहे हैं।

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

नोट: यह एक लोकप्रिय प्रस्ताव है, अगर कोई इसे गोडोट प्रस्तावों पर ले जाता है, तो कृपया चर्चा को भी संक्षेप में प्रस्तुत करने का प्रयास करें।