स्तर एल्गोरिदम का अनुभव PHP

Question

मैं एक गेम विकसित कर रहा हूं और मैं उन स्तरों से भरा सरणी नहीं चाहता था जो उपयोगकर्ता स्तर को खोजने के लिए उनके द्वारा पुन: प्रयास करते समय पेज लोड को अधिकतर बढ़ाएंगे। मुझे केवल उपयोगकर्ता के अनुभव के साथ स्वतंत्र रूप से इसे काम करने के लिए एक एल्गोरिदम की आवश्यकता थी। ऐसा इसलिए है क्योंकि मैं अधिकतम स्तर 1000 के आसपास होना चाहता हूं, और एक सरणी जो लंबे समय तक जाने में कुछ समय लेती है।

मेरे पास है, कुछ मदद के साथ, प्रत्येक स्तर के बीच अंतर के लिए निम्नलिखित कलन विधि के साथ आने:

difference = difference + (difference/7) 

और यह निचले स्तरों पर अच्छी तरह से काम है, लेकिन इस ग्राफ स्तर 1-141 है , और जैसा कि आप देख सकते हैं, यह लगभग आधा रास्ता तक बेहद आसान है, फिर यह शूट हो जाता है और शूटिंग पर चलता है, जब तक यह बिंदु तक पहुंच जाता है 1,500,000,000 अनुभव स्तर ~ 250 है, जो पर्याप्त नहीं है।

तो, मेरे सवाल है, क्या आपको लगता है कि प्रत्येक स्तर के बीच अंतर करने के लिए एक बेहतर तरीका है? किसी भी सलाह का स्वागत है, मैं सभी एल्गोरिदम का परीक्षण करेंगे।

धन्यवाद।

Answer 1

सबसे पहले, रैखिक प्रणाली है।

Level = Experience/1000 

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

फिर विभिन्न प्रकार के घटते-रिटर्न वक्र हैं। उदाहरण के लिए:

Level = (Experience/1000)^(1/scale) 

स्तर 1 के लिए 2 (वर्ग वक्र) के पैमाने के साथ, आपको 1,000 अनुभव की आवश्यकता है। दो के लिए, आपको चार हजार की जरूरत है। तीन, नौ हजार के लिए। प्रत्येक स्तर कठिन और कठिन हो जाता है। यदि आप स्केल को छोटा करते हैं, तो जिस दर पर कठिनाई रैंप कम हो जाती है (ढलान कम खड़ी हो जाती है)।

मैं पहले व्युत्पन्न (जैसा कि आपने ऐसा करने की कोशिश की है) के निर्माण के बजाय कार्य को स्वयं बनाने का सुझाव दिया है। इससे पहले कि आप एकीकृत करने से पहले ग्राफ के बारे में आपको एक बेहतर विचार देंगे।

Answer 2

आप शायद कुछ ऐसा चाहते हैं जिसमें y = 1,000 पर क्षैतिज एसिमप्टेट हो, जो बड़े एक्स के लिए छोटे x के लिए अधिक तेज़ी से बढ़ता है।उदाहरण के लिए, हम प्रणाली

dy/dx = a/x 
lim (x->infinity) y = 1,000 

हम मिल कि

y = C_0 - a/(x^2) 

सीमा का उपयोग करना, हम पाते हैं कि

lim (x->infinity) y = C_0 

तो हम समीकरण प्राप्त हल करने के लिए चाहते हो सकता है

level = 1,000 - a/(exp^2) 

हम सभी उपयोगकर्ताओं को ओ के साथ शुरू कर सकते हैं ne अनुभव, या बस

के लिए इसे बदल

level = 1,000 - a/(exp^2 + 1) 

किसी भी तरह से, उन बाहर स्तर

level(0) = 1,000 - a 

तो पर शुरू होगा यदि आप उन स्तर 0 पर शुरू करना चाहते हैं, चलो एक = 1000; अगर उन स्तर 1 से शुरू, एक = 999 तो मैं निम्नलिखित की सिफारिश कर सकते हैं करते हैं:

level(0) = 1,000 - 1,000(exp^2 + 1) 

0. पर शुरू आप exp की शक्ति बदलकर अभिसरण की दर को बदल सकते हैं अनुभव के लिए; उच्च शक्तियों का मतलब अधिकतम अनुभव के लिए तेज़ अभिसरण है, कम शक्तियों का मतलब अधिक अभिसरण है। पावर 2 सिर्फ एक सुझाव है; कोई भी सकारात्मक वास्तविक शक्ति ठीक रहेगी।

ध्यान दें कि इस तरह के एक समारोह को बनाने के लिए यह केवल एक दृष्टिकोण है। आप किसी भी डीई/डीएक्स को एकीकृत कर सकते हैं जो बड़े एक्स के मुकाबले छोटे एक्स के लिए बड़ा है, और आपको एक और फ़ंक्शन मिलेगा जिसे आप एक ही फैशन में कम या ज्यादा पैरामीटर कर सकते हैं।

Answer 3

वास्तव में, सब कुछ इस बात पर निर्भर करता है कि आप अपनी कठिनाई के अनुसार स्तर कैसे बनाते हैं। वह एल्गोरिदम सेट किया जा सकता है, कि 1 से 1.1 में परिवर्तन 1000 से 1000000 के परिवर्तन की तुलना में बहुत अधिक महसूस किया जाएगा। या, इसके विपरीत।

क्या अलग-अलग श्रेणियों में कठिनाई के लिए algorythm संवेदनशीलता समान सापेक्ष परिवर्तन के लिए समान होगी? या पूर्ण परिवर्तन के लिए? या कठिनाई के दूसरे कार्य और इसके परिवर्तन के लिए? यह आपके लिए तय करना है।

तो, इसकी वृद्धि की कठिनाई और रणनीति का मूल्य केवल एक मनोवैज्ञानिक समस्या है।

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