आरपीजी गेम में हमले के वर्ग को कैसे डिज़ाइन करें?


37

मैं एक छोटे आरपीजी शैली के खेल के नियोजन चरण में हूं।

चरित्र में विशेषताओं का एक सेट होगा, जैसे ताकत, चपलता, आदि जो पूर्णांक के रूप में दर्शाए जाते हैं। चरित्र में एक हमले वर्ग के रूप में प्रतिनिधित्व किए गए हमलों का एक सेट भी होगा।

प्रत्येक हमले पर मैं चाहता हूं कि यह पात्रों की विशेषताओं के आधार पर नुकसान पहुंचाए, उदाहरण के लिए: हमला "तलवार स्लेश" 10 dmg + वर्ण शक्ति का मान करेगा।

जिस तरह से मैं यह करने के लिए सोच रहा था वह एक अमूर्त हमला वर्ग है, जिसमें एक सार हमला विधि है, और प्रत्येक हमले के लिए मैं एक वर्ग बनाता हूं जो हमला विधि को लागू करता है।

public class SwordSlash:Attack
{
    public void Attack(Character attacker, Character defender)
    {
        defender.DoDamage(10 + attacker.Strength);
    }
}

मैं देखता हूं कि यह इसे बनाए रखने के लिए एक बुरा सपना होगा।

क्या किसी को इस बात का अंदाजा है कि मैं इसे अच्छे तरीके से कैसे पूरा कर सकता हूं?

मुझे लगता है कि मुख्य समस्या यह है कि हमले के आधार पर सही विशेषता को कैसे इनपुट किया जाए।

जवाबों:


34

आपको यहां डेटा-संचालित डिज़ाइन के लिए जाना चाहिए।

एक जेनेरिक अटैक क्लास करें जिसमें आपके द्वारा काम करने वाले पैरामीटर शामिल हैं - बेस डैमेज, जो आंकड़े नुकसान को प्रभावित करते हैं, संभावित स्टेटस इफेक्ट का एक सेट ... जैसे सामान:

public enum AttackStat
{
  Strength,
  Agility,
  Intellect
  // etc.
}

public class Attack
{    
  private int baseDamage;
  private AttackStat stat;
  private double damageMultiplier;
  // ...and so on

  public void Attack(Character attacker, Character defender)
  {
    defender.DoDamage(baseDamage + attacker.GetStatValue(stat) * damageMultiplier);
  }    
}

// Put a method on Character to fetch the appropriate value given an AttackStat:
public int GetStatValue(AttackStat s)
{
  switch(s)
  {
    case AttackStat.Strength:
      return strength;
    case AttackStat.Agility:
      return agility;
    // etc.
  }
}

फिर, अपने हमलों को एक फ़ाइल में रखें, उदाहरण के लिए एक XML फ़ाइल, और वहां से डेटा लोड करें:

<Attacks>
  <Attack name="Sword Slash" damage="10" stat="Strength" multiplier="1" />
  <!-- More attacks here -->
</Attacks>

तुम भी कई आँकड़ों से मूल्यों को आकर्षित करने के लिए इसे बढ़ा सकते हैं, कहते हैं, एक आग का गोला जहां क्षति एक बुद्धि और एक आग दोनों से गणना की जाती है:

<Attack name="Fireball" damage="20">
  <StatModifier stat="Intellect" multiplier="0.4" />
  <StatModifier stat="Fire" multiplier="0.8" />
</Attack>

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


1
+1, लेकिन मैं उस स्विच स्टेटमेंट को बनाए रखने से बचने के लिए GetStatValue को किसी प्रकार के लुकअप टेबल से बदल दूंगा।

1
इस पद्धति के साथ समस्या यह है कि आप केवल सामान्य डेटा-चालित हमले कर सकते हैं - आपके पास विशेष तर्क का उपयोग करने वाला कुछ भी नहीं हो सकता है। आप वस्तुओं के एक बहुत ही सामान्य सेट के साथ समाप्त हो जाएंगे (जैसा कि आप युद्धकांड में प्राप्त करते हैं
Iain

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

2
@ मुख्य: केवल अधिक फ़ील्ड्स जोड़ने के अलावा, आप यह भी हल कर सकते हैं कि कुछ डेटा फ़ील्ड्स जैसे कि Lua में भाव या कोड ब्लॉक हैं। ऑर्थोगोनल घटकों का अच्छा उपयोग भी अधिक दिलचस्प परिणाम देता है।

1
डेटा-संचालित होने के सामान्य विचार के लिए +1। मैं xml सुझाव देने से सहमत नहीं हूँ। अगर आप Lua को एम्बेड कर रहे हैं तो बेहतर प्रारूप हैं - yaml, json या सादे .lua फ़ाइल।
एगारिया


2

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


6
-1, यह केवल डेटा-संचालित नहीं है, यह घटक-चालित के बजाय गहरी पदानुक्रम है। यह सबसे खराब संभव समाधान है।

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

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

2
एक आरपीजी खेल होने के नाते, यह शायद हर वस्तु को लागू करने के लिए बहुत अव्यवहारिक है।
वॉन हिल्ट्स

1

मैं वास्तव में इस के लिए नया हूँ, लेकिन जिस तरह से मैं करूँगा वह एक सामान्य हमले वर्ग बनाने के लिए है।

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

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

आशा है कि समझ में आया।

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