खेलों के लिए एक व्यवहार / घटक आधारित प्रणाली बनाएं

Question

पृष्ठभूमि

मैं एक शौक के रूप में खेल विकास करता हूं, और उन्हें डिजाइन करने के लिए बेहतर तरीके की तलाश कर रहा हूं। वर्तमान में, मैं एक मानक OOP दृष्टिकोण का उपयोग कर रहा हूं (मैं 8 साल से उद्यम विकास कर रहा हूं इसलिए यह निष्पक्ष रूप से आता है)। उदाहरण के लिए एक "बैडी" लें

public class Baddie:AnimatedSprite //(or StaticSprite if needed, which inherit Sprite)
{
    //sprite base will have things like what texture to use, 
    //what the current position is, the base Update/Draw/GetInput methods, etc..
    //an AnimatedSprite contains helpers to animated the player while 
    //a StaticSprite is just one that will draw whatever texture is there
}

समस्या

कहते हैं कि मैं एक 2d platformer बना रहा हूं, और बड्डी को कूदने में सक्षम होने की आवश्यकता है। आमतौर पर मैं जो भी करता हूं वह अद्यतन / GetInput विधियों में उपयुक्त कोड जोड़ देता है। फिर अगर मुझे खिलाड़ी को क्रॉल, बतख, चढ़ाई, आदि बनाने की आवश्यकता है ... तो कोड वहां जाएगा।

यदि मैं सावधान नहीं हूँ, तो वे विधियाँ अव्यवस्थित हो जाती हैं, इसलिए मैं इस तरह से विधियाँ जोड़ियाँ बनाता हूँ

CheckForJumpAction(Input input) तथा DoJump()

CheckforDuckAction(Input input) तथा DoDuck()

इसलिए GetInput जैसा दिखता है

public void DoInput(Input input)
{
    CheckForJumpAction(input);
    CheckForDuckAction(input);
}

और अपडेट जैसा दिखता है

public void Update()
{
    DoJump();
    DoDuck();
}

अगर मैं जाता हूं और एक और खेल बनाता हूं जहां खिलाड़ी को कूदने और डक करने की आवश्यकता होती है, तो मैं आमतौर पर एक ऐसे खेल में जाता हूं जिसमें कार्यक्षमता होती है और इसे कॉपी करता है। गन्दा, मुझे पता है। Thats मैं क्यों मैं कुछ बेहतर के लिए देख रहा हूँ।

समाधान?

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

मैं एक आधार व्यवहार वस्तु बनाऊंगा

public class Behavior
{
    public void Update()
    Public void GetInput()
}

और मैं उस का उपयोग करके व्यवहार बना सकता हूं। JumpBehavior:BehaviorतथाDuckBehavior:Behavior

फिर मैं स्प्राइट बेस पर व्यवहारों का एक संग्रह जोड़ सकता हूं और प्रत्येक इकाई के लिए मुझे जो कुछ भी चाहिए उसे जोड़ सकता हूं।

public class Baddie:AnimatedSprite
{
    public Baddie()
    {
        this.behaviors = new Behavior[2];
        this.behaviors[0] = new JumpBehavior();
        //etc...
    }

    public void Update()
    {
        //behaviors.update
    }

    public GetInput()
    {
        //behaviors.getinput
    }
}

तो अब अगर मैं कई खेलों में जंप और डक का उपयोग करना चाहता था, तो मैं व्यवहार को खत्म कर सकता हूं। मैं आम लोगों के लिए एक पुस्तकालय भी बना सकता था।

क्या यह काम करता है?

मैं यह पता नहीं लगा सकता कि उनके बीच की स्थिति को कैसे साझा किया जाए। जंप और डक को देखते हुए, दोनों न केवल बनावट के वर्तमान भाग को प्रभावित करते हैं, बल्कि खिलाड़ी की स्थिति को भी प्रभावित करते हैं। (कूद समय के साथ ऊपर की ओर बल की एक घटती मात्रा लागू करने के लिए जा रहा है, जबकि बतख बस आंदोलन को रोकने के लिए जा रहा है, बुद्दि की बनावट और टकराव के आकार को बदल सकता है।

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

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

इसलिए मैं इसे आप पर पलट देता हूं। यह समझाने के लिए कि यह कैसे किया जा सकता है? क्या आपके पास एक बेहतर विचार है? मैं सुन रहा हु।

Comments

यह बेहतर gamedev.stackexchange.com पर पूछा जा सकता है ?

— बजे

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

— एडवर्ड स्ट्रेंज

@rcapote इस साइट को व्हाइटबोर्डिंग / चर्चा के लिए नहीं रखा गया है?

@ जो - नहीं, नहीं। यहां "चर्चा" का भी उल्लेख न करें या आप अस्तित्व से बाहर होंगे। यह साइट केवल प्रश्न-> उत्तर-> बातचीत के प्रकार के लिए है।

— एडवर्ड स्ट्रेंज

ठीक है, घटक-आधारित इकाई प्रणाली एक ऐसी चीज है जिसने खेल देव समुदाय में हाल ही में ट्रेंड करना शुरू कर दिया है, इसलिए मुझे लगा कि आपको वहां बेहतर ध्यान मिल सकता है, लेकिन आपको शायद यहाँ भी अच्छे उत्तर मिलेंगे। यहाँ इस समस्या के बारे में gamedev.net पर एक दिलचस्प चर्चा है जो आपको दिलचस्प लग सकती है: gamedev.net/topic/…

— r

Answer 1

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

Answer 2

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

(एक आकस्मिक) उदाहरण के लिए:

// The basic definition of the jump behavior
public interface IJumpBehavior {
    void Jump();
}

अब आप विभिन्न प्रकार के जंप को लागू कर सकते हैं जो आपके चरित्र का उपयोग कर सकते हैं, आवश्यक रूप से प्रत्येक विशिष्ट कूद के बारे में विवरण जानने के बिना:

// This is the jump the character may have when first starting
public class NormalJump : IJumpBehavior {

     public void Jump() {
         Console.WriteLine("I am jumping, and being pretty boring about it!");
     }

}

// This is the jump of a character who has consumed a power-up
public class SuperJump : IJumpBehavior {
    public void Jump() { 
         Console.WriteLine("I am all hopped up on star power, now my jumps can do damage!");
     }
}

कोई भी पात्र जिसे आप कूदना चाहते हैं, उसमें अभी एक IJumpable का संदर्भ हो सकता है और आपके विभिन्न कार्यान्वयनों का उपभोग करना शुरू कर सकता है

public class HeroCharacter {

    // By default this hero can perform normal jump.
    private IJumpBehavior _jumpBehavior = new NormalJump();

    public void Jump() {
        _jumpBehvaior.Jump();
    }

    // If you want to change the hero's IJumpable at runtime
    public void SetJump(IJumpBehavior jumpBehavior) {
      _jumpBehavior = jumpBehavior;
    }

}

तब आपका कोड कुछ इस तरह दिख सकता है:

HeroCharacter myHero = new HeroCharacer();

// Outputs: "I am jumping, and being pretty boring about it!"
myHero.Jump()

// After consuming a power-up
myHero.SetJump(new SuperJump());

// Outputs: "I am all hopped up on star power, now my jumps can do damage!"
myHero.Jump();

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

Comments

जबकि बिल्कुल नहीं मैं क्या देख रहा हूँ, यह बहुत करीब है और इसे पसंद है। मैं यह सुनिश्चित करने के लिए इसके साथ खेलने जा रहा हूं। धन्यवाद!

Answer 3

डीसीआई आर्किटेक्चर पर एक नज़र डालें जो ओओ प्रोग्रामिंग पर एक दिलचस्प कदम है जो मदद कर सकता है।

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

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

C # में कोड उदाहरणों के लिए C # में DCI देखें ।

Answer 4

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