गेम की प्रगति के दौरान मैं हमले की लहर में दुश्मनों की संख्या और चुनौती को कैसे माप सकता हूं?

Question

मैं वर्तमान में एक रक्षा खेल बना रहा हूं जहां दुश्मन खिलाड़ी की सेना पर हमला करेंगे और हमला करेंगे। यह एक टॉवर रक्षा खेल के समान है, केवल एक स्तर को छोड़कर। जब तक कि उपयोगकर्ता की मृत्यु नहीं हो जाती है, तब तक दुश्मन मरते रहेंगे या वह एक बड़ी पर्याप्त सेना को इकट्ठा करेगा कि वे किसी भी दुश्मन का सफाया कर दें जो तुरंत पैदा होता है (उम्मीद है कि यह पर्याप्त चुनौतीपूर्ण होगा कि ऐसा नहीं होगा)।

इस समय मैं जो संघर्ष कर रहा हूं, वह यह है कि इस खेल को उत्तरोत्तर कठिन कैसे बनाया जाए और मूल रूप से दुश्मन के शिकार की संभावना अंततः 100% तक पहुंच जाए।

अब तक मुझे निम्नलिखित के समान कुछ मिला है

if(Math.random() < 1 - (1/elapsed_time) && spawnTimer <= 0 ){
    spawnEnemy()
    spawnTimer = rand(); // random number between 1 and 3
}

लेकिन यह भी शुरू करने के लिए एक समान लगता है। फिलहाल मैं केवल एक प्रकार के शत्रु को पैदा कर रहा हूं, यह विचार कि कठिन दुश्मन समय के साथ-साथ आगे बढ़ रहे हैं।

मुझे यह भी लगता है कि मुझे अपने spawnTimerको थोड़ा और बेतरतीब करना होगा और समय की प्रगति के रूप में जल्दी प्राप्त करना होगा, लेकिन मैं सिर्फ अपने सिर को पाने के लिए नहीं देख सकता हूं कि इस पूरे खंड के लिए मेरा तर्क वास्तव में कैसा दिखना चाहिए। क्या कोई इस तरह के सूत्र के मोटे विचार के साथ मदद करने में सक्षम है?

मैं वर्तमान में गेम लिखने के लिए जावास्क्रिप्ट का उपयोग कर रहा हूं, लेकिन जाहिर है कि यह अवधारणा के बारे में अधिक है।

Comments

बीता हुआ समय क्या है? क्या यह अब तक पारित किया गया है? इस स्थिति को आप कितनी बार कहते हैं?

— अट्टुरसम्स

हाय, हाँ खेद बीत चुका समय खेल शुरू होने के बाद का समय बीत चुका है और इसे मेरे गेम अपडेट () चक्र में कहा जाता है, जो

— window.requestAnimationFrame

Answer 1

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

आज्ञा देना threshहो एक कठिनाई सीमा आपको लगता है अधिक है। हम बाद में यह तय करने के लिए उपयोग करते हैं कि उस गति को धीमा करना है जिस पर खेल कठिन हो जाता है।

rateआप जितने राक्षसों को हर मिनट (या गोल) में आना चाहते हैं, बनने दें ।

आज्ञा देना GROWTH_RATEदर है जिसमें कठिनाई बढ़ जाती है (अब के लिए यह हो जाएगा 0.2)।

मान लीजिए कि आप के साथ शुरू करते हैं rate = 10। अब खिलाड़ी ने 5राक्षसों को मार दिया ताकि आप दर GROWTH_RATE * 5 = 1.0और नए को बढ़ा सकें rate = 11।

ऐसी स्थिति कैसे लागू करें जो rateहर मिनट राक्षसों को उत्पन्न करेगी :

बीच की एक संख्या के लिए सेट अंडे टाइमर 0.5के 1.0 multiplied by 60 seconds orदौर के समय and divided byदर . Also leave a0.25` मौका है कि कोई राक्षस जब टाइमर 0 तक पहुँच जाता है और समय फिर से बेतरतीबी से पैदा की है।

अगर rateकभी threshआप तक पहुँचते हैं तो आपको धीमा करना होगा। अब बजाय बढ़ाने की rateद्वारा GROWTH_RATE, आप इसे से बढ़ सकते हैं 1 / math.sqrt(rate)। इस तरह खिलाड़ी कठिन सेटिंग में तुरंत नष्ट नहीं होगा।

खिलाड़ी जिस गेम को खोता है thresh, उस rateपर आप लगभग 80% रीसेट कर सकते हैं ।

यदि आप राक्षस की ताकत को बेतरतीब करना चाहते हैं तो टाइमर के बारे में सतर्क रहें। उदाहरण के लिए, यदि आप यह तय करते हैं कि player-score(अब तक मारे गए राक्षसों द्वारा निर्धारित) का उपयोग किसी राक्षस की अधिकतम ताकत को निर्धारित करने के लिए किया जाएगा, जो आप कर सकते हैं, तो आप ऐसा कुछ कर सकते हैं max-monster-strength = player-score / 1000:। फिर floatया के doubleबीच एक यादृच्छिक 0.0करें 1.0और परिणाम को अपने आप से गुणा करें।

float monster_power = Math.random();
monster_power *= monster_power; // Multiply result by itself
    // Makes hard monsters less frequent than weak ones
monster_power *= max_monster_strength;

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

spawn_timer *= math.sqrt(monster_power);

Answer 2

बहुत सारे विकल्प हैं, आपके वर्तमान सेटअप के साथ दो:

• शत्रुओं को कठोर बनाते हैं
• अधिक दुश्मन (या तो एक बार में या कई बार)

फिर अतिरिक्त सुविधाओं के साथ:

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

कठिनाई वक्र बनाने के लिए, वास्तव में कोई सही उत्तर नहीं है। यह सही होने के लिए बहुत सारे playtesting और tweaking लेने जा रहा है। यह इस बात पर निर्भर करेगा कि खेल कितने समय तक चलना है और आप इसे कितना मुश्किल चाहते हैं। मेरा सुझाव है कि आप एक्सेल या वुल्फरामअल्फा जैसी साइट का उपयोग करें और देखें कि विभिन्न प्रकार के वक्र किस प्रकार के कार्य बनाते हैं। घातीय वृद्धि, रैखिक वृद्धि आदि का प्रयास करें, वह खोजें जो आपके लिए काम करती है।

Comments

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

— बदल

Answer 3

एक परिवर्तनीय संभावना के साथ दुश्मनों की एक निश्चित संख्या (एक) स्पॉन होने के बजाय, आप इसे घुमा सकते हैं और एक निश्चित संभावना के साथ दुश्मनों की एक चर संख्या हो सकती है।

static const double SPAWN_CHANCE_ON_DIFFICULTY_1 = 0.01;

for (int i = 0; i < currentDifficulty; i++) {
   if(Math.random() < SPAWN_CHANCE_ON_DIFFICULTY_1 ){
       spawnEnemy()
   }
}

कठिनाई स्तर 1 पर, इसमें प्रति दुश्मन एक टिक को स्पॉन करने के लिए 1% मौका होगा।

कठिनाई स्तर 1000 पर, यह 1000 दुश्मनों तक फैल जाएगा, प्रत्येक एक 1% के अलग मौके के साथ। इसका मतलब है कि औसतन 10 टिक प्रति स्पॉन होगा, लेकिन यह कम या ज्यादा भी हो सकता है। इस बात की संभावना है कि 10 से बहुत भिन्न संख्या एक ही बार में आएगी, शायद सभी 1000 पर। लेकिन यह संभावना नहीं है कि संभाव्यता कैसे काम करती है (तुलना: बड़ी संख्या के नियम ) के कारण यह बहुत ही अप्रत्याशित घटना है ।

जब आप अलग-अलग व्यवहारों और आँकड़ों के साथ और अधिक शत्रु जोड़ते हैं, तो आप शायद कुछ कठिन दुश्मनों को केवल उच्च कठिनाइयों पर पैदा करना शुरू करते हैं और फिर भी पहले कम घनत्व के साथ। ऐसा करने के लिए आप एक कठिनाई-संशोधक जोड़ सकते हैं जो वर्तमान कठिनाई से घटाया जाता है। इस तरह दुश्मन उस कठिनाई-स्तर तक पहुंचने से पहले ही नहीं फटेगा और तब भी पहली बार में कम मौके के साथ:

for (EnemyType enemyType: allEnemyTypes) {
    for (int i = 0; i < currentDifficulty - enemyType.getDifficulty(); i++) {
        if(Math.random() < enemyType.spawnChance() ){
            spawnEnemy(enemyType);
        }
    }
}

Comments

यह उत्तेजक है लेकिन इसका उपयोग करने से पहले इसे अनुकूलित किया जाना चाहिए। उदाहरण के लिए, आप यह तय करने के लिए कि कितने दुश्मनों को पालना है, एक बार Math.random () का उपयोग कर सकते हैं। यदि आप बड़ी मात्रा में दुश्मनों के लिए एक छोटा मौका छोड़ना चाहते हैं, तो आप "सामान्य वितरण" को अधिक कुशलता से लागू कर सकते हैं। stackoverflow.com/questions/2325472/…

— AturSams