मैं वर्तमान में एक घटक-आधारित इकाई प्रणाली को लागू करने की कोशिश कर रहा हूं, जहां एक इकाई मूल रूप से सिर्फ एक आईडी है और कुछ सहायक तरीके एक घटक का एक गुच्छा बांधकर एक गेम ऑब्जेक्ट बनाते हैं। उस के कुछ लक्ष्यों में शामिल हैं:
- घटकों में केवल स्थिति होती है (उदाहरण के लिए स्थिति, स्वास्थ्य, बारूद गिनती) => तर्क "सिस्टम" में चला जाता है, जो इन घटकों और उनके राज्य को संसाधित करता है (उदाहरण के लिए फ़िज़िक्स सिस्टम, रेंडरसिस्टम, आदि)
- मैं शुद्ध C # और स्क्रिप्टिंग (Lua) के माध्यम से घटकों और प्रणालियों को लागू करना चाहता हूं। मूल रूप से मैं पूरी तरह से नए घटकों और प्रणालियों को परिभाषित करने में सक्षम होना चाहता हूं, जो सीधे Lua में मेरे C # स्रोत को पुन: स्थापित किए बिना।
अब मैं विचारों को खोज रहा हूं कि इसे कुशलतापूर्वक कैसे संभालना है, इसलिए मुझे उदाहरण के लिए C # घटकों या Lua घटकों तक पहुंचने के लिए अलग-अलग सिंटैक्स का उपयोग करने की आवश्यकता नहीं है।
मेरा वर्तमान दृष्टिकोण नियमित, सार्वजनिक गुणों का उपयोग करके सी # घटकों को लागू करना होगा, संभवतः कुछ विशेषताओं के साथ संपादक को डिफ़ॉल्ट मान और सामान के बारे में बताया गया है। तब मेरे पास एक C # क्लास "ScriptComponent" होगा, जो एक लुआ टेबल को आंतरिक रूप से लपेटता है और इस तालिका को एक स्क्रिप्ट द्वारा बनाया जाता है और उस विशेष घटक प्रकार के सभी राज्य को पकड़े रहता है। मैं वास्तव में उस स्थिति को C # पक्ष से एक्सेस नहीं करना चाहता हूं, क्योंकि मुझे संकलन समय पर पता नहीं होगा, कि ScriptCompords क्या गुणों के साथ मेरे लिए उपलब्ध होगा। फिर भी, संपादक को उस तक पहुंचने की आवश्यकता होगी, लेकिन निम्नलिखित जैसे एक सरल इंटरफ़ेस को पर्याप्त होना चाहिए:
public ScriptComponent : IComponent
{
public T GetProperty<T>(string propertyName) {..}
public void SetProperty<T>(string propertyName, T value) {..}
}यह बस लुआ टेबल तक पहुंच जाएगा और लुआ से उन गुणों को सेट और पुनर्प्राप्त करेगा और इसे आसानी से शुद्ध सी # घटकों में भी शामिल किया जा सकता है (लेकिन नियमित सी # गुणों का उपयोग करें, प्रतिबिंब या कुछ के माध्यम से)। यह केवल नियमित गेम कोड द्वारा नहीं, संपादक में उपयोग किया जाएगा, इसलिए यहां प्रदर्शन उतना महत्वपूर्ण नहीं है। यह कुछ घटक विवरणों को दस्तावेज के रूप में उत्पन्न करने या हस्तलिखित करने के लिए आवश्यक होगा, जो एक निश्चित घटक प्रकार वास्तव में प्रदान करता है, लेकिन यह एक बड़ा मुद्दा नहीं होगा और पर्याप्त रूप से स्वचालित हो सकता है।
हालांकि, लुआ पक्ष से घटकों का उपयोग कैसे करें? अगर मैं कुछ करने के लिए कॉल करता getComponentsFromEntity(ENTITY_ID)हूं जैसे कि मैं शायद केवल मूल सी # घटकों का एक गुच्छा प्राप्त करूंगा, जिसमें "ScriptComponent" भी शामिल है, उपयोगकर्ताडेटा के रूप में। लिपटी हुई लुआ टेबल से मानों को एक्सेस करने से मुझे GetProperty<T>(..)अन्य सी # घटकों के साथ सीधे गुणों तक पहुंचने के बजाय विधि को कॉल करना होगा ।
हो सकता है कि getComponentsFromEntity()केवल एक विशेष विधि लिखी जाए जिसे लुआ से पुकारा जा सके, जो सभी मूल सी # घटकों को उपयोगकर्ताडेटा के रूप में लौटाता है, सिवाय "स्क्रिप्टकंपोनेंट" के, जहां यह बदले हुए टेबल को लौटाएगा। लेकिन अन्य घटक-संबंधित तरीके होंगे और मैं वास्तव में C # कोड या Lua स्क्रिप्ट से कॉल करने के लिए इन सभी विधियों की नकल नहीं करना चाहता।
अंतिम लक्ष्य सभी प्रकार के घटकों को एक ही तरह से संभालना होगा, जिसमें कोई विशेष मामला वाक्यविन्यास नहीं होगा, जो मूल घटकों और लुआ घटकों के बीच विभेदित हो - विशेषकर लुआ पक्ष से। जैसे मैं एक Lua स्क्रिप्ट लिखने में सक्षम होना चाहता हूँ:
entity = getEntity(1);
nativeComponent = getComponent(entity, "SomeNativeComponent")
scriptComponent = getComponent(entity, "SomeScriptComponent")
nativeComponent.NativeProperty = 5
scriptComponent.ScriptedProperty = 3स्क्रिप्ट को इस बात की परवाह नहीं करनी चाहिए कि यह वास्तव में किस तरह का घटक है और मैं उन्हीं तरीकों का उपयोग करना चाहूंगा जिन्हें मैं घटकों को पुनः प्राप्त करने, जोड़ने या हटाने के लिए C # की ओर से उपयोग करूंगा।
हो सकता है कि इस तरह इकाई प्रणालियों के साथ स्क्रिप्टिंग को एकीकृत करने के कुछ नमूना कार्यान्वयन हैं?