कैसे एक shmup स्तर स्टोर करने के लिए?


12

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

क्या यह समय पर आधारित होगा? अद्यतन? दूरी?

वर्तमान में मैं इसे "स्तर के समय" के आधार पर करता हूं (जिस स्तर पर समय चल रहा है - रुकने का समय अपडेट नहीं होता है)। यहाँ एक उदाहरण है (क्रमांकन XNA द्वारा किया गया था):

<?xml version="1.0" encoding="utf-8"?>
<XnaContent xmlns:level="pekalicious.xanor.XanorContentShared.content.level">
  <Asset Type="level:Level">
    <Enemies>
      <Enemy>
        <EnemyType>data/enemies/smallenemy</EnemyType>
        <SpawnTime>PT0S</SpawnTime>
        <NumberOfSpawns>60</NumberOfSpawns>
        <SpawnOffset>PT0.2S</SpawnOffset>
      </Enemy>
      <Enemy>
        <EnemyType>data/enemies/secondenemy</EnemyType>
        <SpawnTime>PT0S</SpawnTime>
        <NumberOfSpawns>10</NumberOfSpawns>
        <SpawnOffset>PT0.5S</SpawnOffset>
      </Enemy>
      <Enemy>
        <EnemyType>data/enemies/secondenemy</EnemyType>
        <SpawnTime>PT20S</SpawnTime>
        <NumberOfSpawns>10</NumberOfSpawns>
        <SpawnOffset>PT0.5S</SpawnOffset>
      </Enemy>
      <Enemy>
        <EnemyType>data/enemies/boss1</EnemyType>
        <SpawnTime>PT30S</SpawnTime>
        <NumberOfSpawns>1</NumberOfSpawns>
        <SpawnOffset>PT0S</SpawnOffset>
      </Enemy>
    </Enemies>
  </Asset>
</XnaContent>

प्रत्येक शत्रु तत्व मूल रूप से विशिष्ट दुश्मन प्रकारों की एक लहर है। प्रकार को EnemyType में परिभाषित किया गया है, जबकि SpawnTime "लेवल टाइम" है, यह लहर दिखाई देनी चाहिए। NumberOfSpawns और SpawnOffset दुश्मनों की संख्या है जो क्रमशः दिखाई देंगे और प्रत्येक स्पॉन के बीच समय लगेगा।

यह एक अच्छा विचार हो सकता है या वहाँ से बेहतर हो सकता है। मुझे यकीन नहीं है। मैं कुछ राय और विचार देखना चाहूंगा।

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

के रूप में सही ढंग से spawning के लिए, समस्या इस तथ्य में निहित है कि मेरे पास एक चर अद्यतन समय है और इसलिए मुझे यह सुनिश्चित करने की आवश्यकता है कि मैं एक दुश्मन स्पॉन को याद नहीं करता हूं क्योंकि स्पॉन ऑफसेट बहुत छोटा है, या क्योंकि अपडेट में थोड़ा और समय लगता है । मैंने थोड़े समय के लिए इसे तय किया, लेकिन मुझे लगता है कि समस्या यह है कि मैं स्तर कैसे संग्रहीत करता हूं।

तो, कोई विचार? टिप्पणियाँ?

पहले ही, आपका बहुत धन्यवाद।

जवाबों:


4

ऐसा करने का एक तरीका समय पर नहीं बल्कि क्षैतिज दूरी पर यात्रा करना (पक्षों को नियंत्रित करना) के आधार पर होगा। आप एक ट्रिगर दूरी के साथ एक कतार में अपने दुश्मन तरंगों को स्टोर कर सकते हैं; जब आपके खिलाड़ी की दूरी कतार के मोर्चे पर ऑब्जेक्ट की ट्रिगर दूरी से अधिक है, तो इसे कतार से पॉप करें और इसे स्पॉन करें।

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


4
और एक बोनस के रूप में यदि आप स्क्रॉलिंग गति को बदलते हैं, या तो विश्व स्तर पर, या स्तर के एक खंड के लिए, यह बाद में दुश्मनों को उनके सही स्पॉन पदों में रखेगा, क्योंकि यदि यह समय आधारित थे, तो दुश्मन सही स्थानों पर स्पॉन करेंगे।
AttackingHobo

2

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

लहर पैटर्न निश्चित रूप से क्रमिक रूप से bezier घटता द्वारा योजना बनाई जा सकती है (विकिपीडिया पृष्ठ में यह समझाने के लिए एक साफ-सुथरा एनीमेशन है)।

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

HTH।


मैं पहले से ही दुश्मन की हरकतों को (जो कि xml में भी क्रमबद्ध है) स्टोर करने के लिए बेजियर कर्व्स का उपयोग करता हूं। मैं मुख्य रूप से XML का उपयोग कर रहा हूं क्योंकि .NET और XNA दोनों में सीरियललाइजेशन / डिसिएरलाइजेशन के लिए अंतर्निहित समर्थन है। LUA स्क्रिप्ट अच्छी लगती है लेकिन इसके लिए अधिक मेहनत करनी होगी। हालांकि, मैंने हमेशा इसका उपयोग करने की योजना बनाई है, इसलिए कुछ बुनियादी इंजन खत्म करने के बाद, मैं निश्चित रूप से इस पर गौर करूंगा। Finallt, पिछले एक के बाद एक लहर पैदा करने का आरई विचार दिलचस्प लगता है।
pek

2
XML ठीक है, जब तक यह एक उपकरण द्वारा उत्पन्न होता है, और हाथ से संपादित नहीं किया जाता है। Whilst पटकथा भाषाओं विशेष मामलों (जैसे मालिकों) के लिए उपयोगी हो सकता है, कि मानक हमले पैटर्न को परिभाषित करने के लिए एक पूरी तरह से अलग समस्या है, है ना?
ब्‍लूस्‍क्रॉन

0

प्रक्रियात्मक रूप से पैदा करने वाले दुश्मनों पर विचार करें। मुझे पता है कि यह आपके इच्छित उत्तर से काफी अलग है, और यह अप्रत्यक्ष रूप से समस्या को पूरी तरह हल करता है।

यदि मैं ऐसा करता था, तो मैं प्रत्येक शत्रु इकाई को "अंक" मान देता हूं कि यह कितना कठिन है, तो कुछ अंकों के स्तरों को असाइन करें - 100 अंक एक सौ 1 अंक के दुश्मन या 100-बिंदु वाले दुश्मन के लायक हैं, या बीच में कुछ भी।

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

आप इसे एक कदम आगे ले जा सकते हैं जिसमें संरचनाएँ हैं: पदों और बिंदुओं का संग्रह, उदाहरण के लिए। एक एकल पंक्ति (पंक्ति या स्तंभ) में सात एक-बिंदु दुश्मन, या दो 3-बिंदुओं से पांच-बिंदु flanked।

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