एक घटक-आधारित प्रणाली में पावरअप करना


29

मैं बस घटक आधारित डिजाइन के आसपास वास्तव में अपना सिर शुरू कर रहा हूं। मुझे नहीं पता कि ऐसा करने का "सही" तरीका क्या है।

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

इस तरह की ढाल एक घटक आधारित खेल में किस तरह से निर्मित होती है?

जहाँ मुझे भ्रम हो रहा है कि ढाल में स्पष्ट रूप से तीन घटक हैं।

  • नुकसान में कमी / फ़िल्टरिंग
  • एक प्रेत
  • एक कोलिडर।

इसे बदतर बनाने के लिए अलग-अलग ढाल विविधताओं में और भी अधिक व्यवहार हो सकते हैं, जिनमें से सभी घटक हो सकते हैं:

  • खिलाड़ी अधिकतम स्वास्थ्य को बढ़ावा दें
  • स्वास्थ्य का उत्थान
  • प्रक्षेप्य विक्षेप
  • आदि

  1. क्या मैं इसे उखाड़ फेंक रहा हूं? क्या ढाल सिर्फ एक सुपर घटक होना चाहिए?
    मुझे वास्तव में लगता है कि यह गलत उत्तर है। तो अगर आपको लगता है कि यह तरीका है तो कृपया समझाएं।

  2. क्या ढाल की अपनी इकाई होनी चाहिए जो खिलाड़ी के स्थान को ट्रैक करती है?
    क्षति फ़िल्टरिंग को लागू करना कठिन हो सकता है। यह थोड़े संलग्न घटकों और संस्थाओं के बीच की रेखाओं को भी धुंधला करता है।

  3. क्या ढाल एक ऐसा घटक होना चाहिए जिसमें अन्य घटक हों?
    मैंने कभी इस तरह का कुछ भी नहीं देखा या सुना है, लेकिन शायद यह आम है और मैं अभी पर्याप्त गहरी नहीं हूं।

  4. क्या ढाल को केवल एक घटक होना चाहिए जो खिलाड़ी में जुड़ जाए?
    संभवतः दूसरों को प्रबंधित करने के लिए एक अतिरिक्त घटक के साथ, जैसे कि वे सभी एक समूह के रूप में निकाले जा सकते हैं। (गलती से नुकसान कम करने वाले घटक को पीछे छोड़ दें, अब यह मजेदार होगा)।

  5. कुछ और है जो अधिक घटक अनुभव वाले किसी व्यक्ति के लिए स्पष्ट है?


मैंने आपके शीर्षक को अधिक विशिष्ट बनाने की स्वतंत्रता ली।
टेट्राद

जवाबों:


11

क्या ढाल की अपनी इकाई होनी चाहिए जो खिलाड़ी के स्थान को ट्रैक करती है? क्षति फ़िल्टरिंग को लागू करना कठिन हो सकता है। यह थोड़े संलग्न घटकों और संस्थाओं के बीच की रेखाओं को भी धुंधला करता है।

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

क्या ढाल एक ऐसा घटक होना चाहिए जिसमें अन्य घटक हों? मैंने कभी इस तरह का कुछ भी नहीं देखा या सुना है, लेकिन शायद यह आम है और मैं अभी पर्याप्त गहरी नहीं हूं।

इसे एक अलग परिप्रेक्ष्य में देखें; एक घटक जोड़ने से अन्य घटकों को भी जोड़ा जाता है, और हटाने पर, अतिरिक्त घटक भी चले जाते हैं।

क्या ढाल को केवल एक घटक होना चाहिए जो खिलाड़ी में जुड़ जाए? संभवतः दूसरों को प्रबंधित करने के लिए एक अतिरिक्त घटक के साथ, जैसे कि वे सभी एक समूह के रूप में निकाले जा सकते हैं। (गलती से नुकसान कम करने वाले घटक को पीछे छोड़ दें, अब यह मजेदार होगा)।

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

कुछ और है जो अधिक घटक अनुभव वाले किसी व्यक्ति के लिए स्पष्ट है?

मैं थोड़ा विस्तार करने जा रहा हूं।

मेरा मानना ​​है कि आपने देखा कि कैसे कुछ घटकों को प्राथमिकता दी जानी चाहिए, जब वे एक इकाई में जोड़े गए हों (यह आपके अन्य प्रश्न का भी उत्तर देगा)।

मैं यह भी मानने जा रहा हूं कि हम संदेश-आधारित संचार का उपयोग कर रहे हैं (चर्चा के लिए, यह इस समय एक विधि कॉल पर एक अमूर्त है)।

जब भी एक ढाल घटक "स्थापित" होता है, तो ढाल घटक संदेश संचालकों को एक विशिष्ट (उच्च) आदेश के साथ जंजीर किया जाता है।

Handler Stage    Handler Level     Handler Priority
In               Pre               System High
Out              Invariant         High
                 Post              AboveNormal
                                   Normal
                                   BelowNormal
                                   Low
                                   System Low

In - incoming messages
Out - outgoing messages
Index = ((int)Level | (int)Priority)

"आँकड़े" घटक इन / इनवेरिएंट / नॉर्मल इंडेक्स में एक "क्षति" संदेश हैंडलर स्थापित करता है। हर बार एक "क्षति" संदेश प्राप्त होता है, इसकी "मूल्य" राशि से एचपी को कम करें।

उचित मानक व्यवहार (कुछ प्राकृतिक क्षति प्रतिरोध और / या नस्लीय लक्षणों में डाल दिया, जो भी हो)।

शील्ड घटक इन / प्री / हाई इंडेक्स पर "क्षति" संदेश हैंडलर स्थापित करता है।

Every time a "damage" message is received, deplete the shield energy and substract
the shield energy from the damage value, so that the damage down the message
handler pipeline is reduced.

damage -> stats
    stats
        stats.hp -= damage.value

damage -> shield -> stats
    shield
        if(shield.energy) {
            remove_me();
            return;
        }
        damage.value -= shield.energyquantum
        shield.energy -= shield.energyquantum;

     stats
        stats.hp -= damage.value

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

समझ में आता है? मुझे बताएं कि क्या मैं और अधिक विवरण जोड़ सकता हूं।

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


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

@ ठीक है, मैं किसी भी तरह से किसी को कुछ भी सिखाने की कोशिश नहीं कर रहा हूं, बल्कि इस विषय पर जो मुझे पता है उसे साझा करना है। लेकिन मैं उस "नहीं" के पीछे एक तर्क जोड़ने जा रहा हूं जो उम्मीद है कि अप्रिय अप्रिय को दूर करेगा :(
रेन

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

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

@deft_code, कृपया मुझे बताएं कि क्या मैं अपने उत्तर में सुधार कर सकता हूं।
राइन

4

1) क्या मैं इसे उखाड़ फेंक रहा हूं? क्या ढाल सिर्फ एक सुपर घटक होना चाहिए?

हो सकता है, इस बात पर निर्भर करता है कि आप अपने कोड को कितना पुन: प्रयोज्य चाहते हैं और यदि यह समझ में आता है।

2) क्या ढाल की अपनी इकाई होनी चाहिए जो खिलाड़ी के स्थान को ट्रैक करती है?

तब तक नहीं जब तक यह ढाल किसी प्रकार का प्राणी नहीं है जो किसी न किसी चरण में स्वतंत्र रूप से घूम सकता है।

3) क्या ढाल एक ऐसा घटक होना चाहिए जिसमें अन्य घटक हों?

यह इकाई की तरह लगता है, इसलिए उत्तर नहीं है।

4) क्या ढाल को केवल उन घटकों का एक सेट होना चाहिए जो खिलाड़ी में जोड़े जाते हैं?

यह संभावना है।

"नुकसान में कमी / फ़िल्टरिंग"

  • कोर ढाल घटक कार्यक्षमता।

"ए स्प्राइट"

  • क्या कोई कारण है कि आप अपने चरित्र इकाई में एक और SpriteComponent नहीं जोड़ सकते हैं (दूसरे शब्दों में प्रति इकाई एक प्रकार के एक से अधिक घटक)?

"एक कोलाइडर"

  • क्या आप सुनिश्चित हैं कि आपको एक और की आवश्यकता है? यह आपके भौतिकी इंजन पर निर्भर करता है। क्या आप चरित्र इकाई ColliderComponent को संदेश भेज सकते हैं और इसे आकार बदलने के लिए कह सकते हैं?

"बूस्ट प्लेयर अधिकतम स्वास्थ्य, स्वास्थ्य पुनर्जनन, प्रक्षेप्य विक्षेपण आदि।"

  • अन्य कलाकृतियां ऐसा करने में सक्षम हो सकती हैं (तलवारें, जूते, अंगूठियां, मंत्र / औषधि / मंदिरों के दर्शन आदि) इसलिए इन घटकों को करना चाहिए।

3

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

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

हर टिक से खिलाड़ी की स्थिति के लिए ढाल इकाई की स्थिति निर्धारित करें। (ऐसा करने वाले पुन: प्रयोज्य घटक वर्ग को लिखें: एक बार लिखें, कई बार उपयोग करें।)

आपको ढाल इकाई बनाने की आवश्यकता होगी, जैसे। एक पावरअप इकट्ठा करने पर। मैं एक सामान्य अवधारणा का उपयोग करता हूं जिसे एमिटर कहा जाता है, जो एक प्रकार का इकाई घटक है जो नई संस्थाओं को जन्म देता है (आमतौर पर एक एंटिटीफैक्ट्री के उपयोग के माध्यम से जिसे यह संदर्भित करता है)। जहाँ आप तय करना चाहते हैं कि एमिटर आपके ऊपर है - जैसे। इसे पॉवरअप पर रखें और पॉवरअप एकत्र होने पर इसे ट्रिगर करें।


क्या ढाल की अपनी इकाई होनी चाहिए जो खिलाड़ी के स्थान को ट्रैक करती है? क्षति फ़िल्टरिंग को लागू करना कठिन हो सकता है। यह थोड़े संलग्न घटकों और संस्थाओं के बीच की रेखाओं को भी धुंधला करता है।

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


3

क्या ढाल एक ऐसा घटक होना चाहिए जिसमें अन्य घटक हों?

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

class Shield : Component
{
    void Start() // happens when the component is added
    {
        sprite = entity.add_component<Sprite>( "shield" );
        collider = entity.add_component<Collider>( whatever );
        //etc
    }

    void OnDestroy() // when the component is removed
    {
        entity.remove_component( sprite );
        entity.remove_component( collider );
    }

    void Update() // every tick
    {
        if( ShouldRemoveSelf() ) // probably time based or something
            entity.remove_component( this );
    }
}

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

यह कम भ्रमित होता अगर मैं इस्तेमाल करता gameObjectया कुछ करता। यह वर्तमान गेम ऑब्जेक्ट / इकाई / जो कुछ भी घटक का मालिक है का संदर्भ है।
टेट्राद

0

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

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

camera template
    moveable
    {
        keyreaction = "scriptforcameramoves"

    }  

player template
    moveable
    {
        keyreaction = "scriptfroplayerkeypress"

    }  

तब मेरे चल घटक में मैसेज रजिस्टर करने के दौरान मैं लिपियों को पंजीकृत करता हूं विधि (C # में कोड)

Owner.RegisterHandler<InputStateInformation>(MessageType.InputUpdate, kScript.Do);

बेशक यह मेरे Do विधि पर निर्भर करता है जो मेरे रजिस्टरहैंडलर के कार्यों के पैटर्न के बाद होता है। इस मामले में इसका (IComponent प्रेषक, रेफ टाइप तर्क)

इसलिए मेरी "स्क्रिप्ट" (मेरे मामले में भी सी # रनटाइम संकलित) को परिभाषित करता है

 public class CameraMoveScript : KeyReactionScript
{
 public override void Do(IComponent pSender, ref InputStateInformation inputState)
 {
    //code here
 }
}

और मेरा आधार वर्ग KeyReactionScript

public class KeyReactionScript : Script
{
      public virtual void Do(IComponent pSender, ref InputStateInformation inputState);
}

फिर बाद में जब एक इनपुट कंपोनेंट MessageTypes.InputUpdate प्रकार का संदेश भेजता है, जैसे टाइप

 InputStateInformation myInputState = InputSystem.GetInputState();
 SendMessage<InputStateInformation>(MessageTypes.InputUpdate, ref myInputState);

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

कोड मेरे इंजन के लिए काफी विशिष्ट है, लेकिन तर्क किसी भी मामले में कार्यात्मक होना चाहिए। मैं घटक संरचना को सरल और लचीला बनाए रखने के लिए कई प्रकारों के लिए ऐसा करता हूं।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.