शोर सुविधाओं से नक्शे बनाना

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


मैं यह नहीं समझाऊंगा कि ऐसे कार्ड कैसे बनाएं: यह भाषा, ग्राफिक्स लाइब्रेरी, प्लेटफॉर्म आदि पर निर्भर करता है। मैं सिर्फ यह बताऊंगा कि मैप डेटा के साथ एरे को कैसे पॉप्युलेट किया जाए ।

शोर

2 डी मानचित्र उत्पन्न करने का एक मानक तरीका एक सीमित आवृत्ति बैंड के साथ शोर का उपयोग भवन ब्लॉक के रूप में करना है, जैसे कि पेर्लिन शोर या सिंप्लेक्स शोर। यहाँ शोर समारोह कैसा दिखता है:


हम मानचित्र पर प्रत्येक बिंदु पर 0.0 से 1.0 तक की संख्या प्रदान करते हैं। इस छवि में, 0.0 काला है और 1.0 सफेद है। यहां देखें कि C जैसी भाषा के सिंटैक्स में प्रत्येक ग्रिड बिंदु का रंग कैसे सेट करें:

for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { double nx = x/width - 0.5, ny = y/height - 0.5; value[y][x] = noise(nx, ny); } } 

लूप जावास्क्रिप्ट, पायथन, हैक्स, सी ++, सी #, जावा, और अधिकांश अन्य लोकप्रिय भाषाओं में समान काम करेगा, इसलिए मैं इसे सी-जैसे सिंटैक्स में दिखाऊंगा ताकि आप इसे उस भाषा में बदल सकें, जिसकी आपको ज़रूरत है। बाकी ट्यूटोरियल में, मैं दिखाऊंगा कि किस तरह से कई फंक्शन जोड़ने पर साइकिल का शरीर बदल जाता है (लाइन value[y][x]=… )। डेमो एक पूर्ण उदाहरण दिखाएगा।

कुछ पुस्तकालयों में, उन्हें 0.0 से 1.0 तक की सीमा में वापस करने के लिए परिणामी मूल्यों को स्थानांतरित करना या गुणा करना आवश्यक होगा।

ऊंचाई

अपने आप में शोर केवल संख्याओं का एक संग्रह है। हमें इसे अर्थ देने की जरूरत है । पहली चीज जिसके बारे में आप सोच सकते हैं, वह यह है कि शोर के मूल्य को ऊँचाई पर बाँध दिया जाए (इसे "ऊँचाई का नक्शा" कहा जाता है)। आइए ऊपर दिखाए गए शोर को लें और इसे ऊंचाइयों पर ले जाएं:



आंतरिक लूप के अपवाद के साथ कोड लगभग समान था। अब यह इस तरह दिखता है:

 elevation[y][x] = noise(nx, ny); 

हां, और यह बात है मानचित्र डेटा समान रहा, लेकिन अब मैं उन्हें elevation (ऊंचाई) कहूंगा, value नहीं।

हमें बहुत सारी पहाड़ियां मिलीं, लेकिन इससे ज्यादा कुछ नहीं। क्या गलत है?

आवृत्ति

किसी भी आवृत्ति पर शोर उत्पन्न किया जा सकता है। अब तक मैंने केवल एक आवृत्ति चुनी है। आइए देखें कि यह कैसे प्रभावित करता है।

स्लाइडर के साथ मान बदलने की कोशिश करें (मूल लेख में) और देखें कि विभिन्न आवृत्तियों पर क्या होता है:


यह सिर्फ पैमाना बदलता है। पहली बार में यह बहुत उपयोगी नहीं है, लेकिन ऐसा नहीं है। मेरे पास एक और ट्यूटोरियल है (हैबे में अनुवाद ), जो सिद्धांत की व्याख्या करता है : आवृत्ति, आयाम, अष्टक, गुलाबी और नीले शोर, और इसी तरह की अवधारणाएं।

 elevation[y][x] = noise(freq * nx, freq * ny); 

यह कभी-कभी वेवलेंथ को याद करने के लिए भी उपयोगी है, जो परिमाण का पारस्परिक है। जब आवृत्ति दोगुनी हो जाती है, तो आकार केवल आधा होता है। तरंग दैर्ध्य को दोगुना करना। तरंग दैर्ध्य पिक्सल / टाइल / मीटर या किसी अन्य इकाइयों में मापी जाने वाली दूरी है जिसे आपने नक्शे के लिए चुना है। यह आवृत्ति से संबंधित है: wavelength = map_size / frequency ।

सप्टक

ऊंचाई के नक्शे को अधिक रोचक बनाने के लिए, हम विभिन्न आवृत्तियों के साथ शोर जोड़ेंगे :

 elevation[y][x] = 1 * noise(1 * nx, 1 * ny); + 0.5 * noise(2 * nx, 2 * ny); + 0.25 * noise(4 * nx, 2 * ny); 

आइए एक नक्शे में छोटे उच्च आवृत्ति वाली पहाड़ियों के साथ बड़ी कम आवृत्ति वाली पहाड़ियों को मिलाएं। मिश्रण में छोटी पहाड़ियों को जोड़ने के लिए स्लाइडर (मूल लेख में) को स्थानांतरित करें:


अब यह बहुत अधिक है जैसे कि भग्न राहत हमें चाहिए! हमें पहाड़ियाँ और उबड़-खाबड़ पहाड़ मिल सकते हैं, लेकिन हमारे पास अभी भी समतल मैदान नहीं हैं। ऐसा करने के लिए, आपको कुछ और चाहिए।

पुनः आबंटन

शोर फ़ंक्शन हमें लाइब्रेरी के आधार पर 0 और 1 (या -1 से +1 के बीच का मान देता है)। समतल मैदान बनाने के लिए, हम ऊंचाई को एक शक्ति तक बढ़ा सकते हैं। विभिन्न डिग्री प्राप्त करने के लिए स्लाइडर (मूल लेख में) को स्थानांतरित करें ।

 e = 1 * noise(1 * nx, 1 * ny); + 0.5 * noise(2 * nx, 2 * ny); + 0.25 * noise(4 * nx, 4 * ny); elevation[y][x] = Math.pow(e, exponent); 

उच्च मूल्य मैदानी क्षेत्रों की औसत ऊँचाई को कम करते हैं, और निम्न मान पर्वत की चोटियों की ओर औसत ऊँचाई बढ़ाते हैं। हमें उन्हें छोड़ना होगा। मैं शक्ति कार्यों का उपयोग करता हूं क्योंकि वे सरल हैं, लेकिन आप किसी भी वक्र का उपयोग कर सकते हैं; मेरे पास अधिक जटिल डेमो है ।

अब जब हमारे पास एक यथार्थवादी उन्नयन मानचित्र है, तो हम बायोम को जोड़ते हैं!

बायोम

शोर नंबर देता है, लेकिन हमें जंगलों, रेगिस्तानों और महासागरों के साथ एक मानचित्र की आवश्यकता है। पहली चीज़ जो आप कर सकते हैं वह है पानी में छोटी ऊँचाई:

 function biome(e) { if (e < waterlevel) return WATER; else return LAND; } 

वाह, यह पहले से ही एक प्रक्रियात्मक रूप से उत्पन्न दुनिया की तरह बन रहा है! हमारे पास पानी, घास और बर्फ है। लेकिन क्या होगा अगर हमें और अधिक की आवश्यकता है? चलो पानी, रेत, घास, जंगल, सवाना, रेगिस्तान और बर्फ का क्रम बनाते हैं:



ऊंचाई के आधार पर राहत

 function biome(e) { if (e < 0.1) return WATER; else if (e < 0.2) return BEACH; else if (e < 0.3) return FOREST; else if (e < 0.5) return JUNGLE; else if (e < 0.7) return SAVANNAH; else if (e < 0.9) return DESERT; else return SNOW; } 

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



ऊपर ऊंचाइयों का शोर है; नीचे - नमी का शोर

अब एक साथ ऊंचाई और आर्द्रता का उपयोग करते हैं । नीचे दिखाई गई पहली छवि में, y अक्ष ऊँचाई है (ऊपर की छवि से लिया गया है), और x अक्ष आर्द्रता (दूसरी छवि अधिक है)। यह हमें एक सम्मोहक नक्शा देता है:



दो शोर मूल्यों पर आधारित राहत

छोटी ऊँचाई महासागरों और तटों हैं। महान ऊंचाइयां चट्टानी और बर्फीली हैं। बीच में, हमें बायोम की एक विस्तृत श्रृंखला मिलती है। कोड इस तरह दिखता है:

 function biome(e, m) { if (e < 0.1) return OCEAN; if (e < 0.12) return BEACH; if (e > 0.8) { if (m < 0.1) return SCORCHED; if (m < 0.2) return BARE; if (m < 0.5) return TUNDRA; return SNOW; } if (e > 0.6) { if (m < 0.33) return TEMPERATE_DESERT; if (m < 0.66) return SHRUBLAND; return TAIGA; } if (e > 0.3) { if (m < 0.16) return TEMPERATE_DESERT; if (m < 0.50) return GRASSLAND; if (m < 0.83) return TEMPERATE_DECIDUOUS_FOREST; return TEMPERATE_RAIN_FOREST; } if (m < 0.16) return SUBTROPICAL_DESERT; if (m < 0.33) return GRASSLAND; if (m < 0.66) return TROPICAL_SEASONAL_FOREST; return TROPICAL_RAIN_FOREST; } 

यदि आवश्यक हो, तो आप इन सभी मूल्यों को अपने खेल की आवश्यकताओं के अनुसार बदल सकते हैं।

अगर हमें बायोम की आवश्यकता नहीं है, तो चिकनी ग्रेडिएंट्स ( इस लेख को देखें ) रंग बना सकते हैं:



बायोम और ग्रेडिएंट दोनों के लिए, एक एकल शोर मान पर्याप्त परिवर्तनशीलता प्रदान नहीं करता है, लेकिन दो पर्याप्त है।

जलवायु

पिछले अनुभाग में, मैंने ऊंचाई को तापमान के विकल्प के रूप में इस्तेमाल किया। ऊंचाई जितनी अधिक होगी, तापमान उतना ही कम होगा। हालांकि, भौगोलिक अक्षांश तापमान को भी प्रभावित करता है। तापमान को नियंत्रित करने के लिए ऊंचाई और अक्षांश दोनों का उपयोग करें:


ध्रुवों (बड़े अक्षांशों) के पास जलवायु अधिक ठंडी है, और पहाड़ों की चोटी (बड़ी ऊँचाई) पर जलवायु भी ठंडी है। अभी तक मैंने इसे बहुत कठिन काम नहीं किया है: इन मापदंडों के लिए सही दृष्टिकोण के लिए, आपको बहुत अधिक सूक्ष्म सेटिंग्स की आवश्यकता है।

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

द्वीप

कुछ परियोजनाओं में, मुझे पानी होने के लिए नक्शे की सीमाओं की आवश्यकता थी। यह दुनिया को एक या एक से अधिक द्वीपों में बदल देता है। ऐसा करने के कई तरीके हैं, लेकिन मैंने अपने बहुभुज मानचित्र जनरेटर में काफी सरल समाधान का उपयोग किया: मैंने ऊंचाई को e = e + a - b*d^c रूप में बदल दिया, जहां d केंद्र से दूरी (0-1 के पैमाने पर) है। एक अन्य विकल्प e = (e + a) * (1 - b*d^c) को बदलना है। निरंतर सब कुछ ऊपर उठाता है, b किनारों को कम करता है, और c गिरावट की दर को नियंत्रित करता है।


मैं इससे पूरी तरह संतुष्ट नहीं हूं और बहुत कुछ पता लगाया जाना बाकी है। क्या यह मैनहट्टन या यूक्लिडियन दूरी होनी चाहिए? क्या यह केंद्र की दूरी या किनारे की दूरी पर निर्भर होना चाहिए? क्या दूरी चुकानी चाहिए, या रैखिक होना चाहिए, या कुछ अन्य डिग्री होनी चाहिए? क्या यह जोड़ / घटाव, या गुणा / भाग, या कुछ और होना चाहिए? मूल लेख में, Add a = 0.1, b = 0.3, c = 2.0, या मल्टीप्ली, a = 0.05, b = 1.00, c = 1.5 का प्रयास करें। आपके लिए उपयुक्त विकल्प आपके प्रोजेक्ट पर निर्भर करते हैं।

क्यों गणित के मानक कार्यों से बिल्कुल चिपके रहते हैं? जैसा कि मैंने अपने लेख में आरपीजी में नुकसान के बारे में बताया (हैबे पर अनुवाद ), हर कोई (मेरे सहित) गणितीय कार्यों का उपयोग करता है, जैसे कि बहुपद, घातीय वितरण, आदि, लेकिन कंप्यूटर पर हम उनके लिए सीमित नहीं हो सकते हैं। हम e = e + height_adjust[d] टेबल e = e + height_adjust[d] का उपयोग करके किसी भी गठन फ़ंक्शन को ले सकते हैं और इसका उपयोग कर सकते हैं। अभी तक मैंने इस मुद्दे का अध्ययन नहीं किया है।

स्पाइकी शोर

ऊंचाई को एक शक्ति तक बढ़ाने के बजाय, हम तीखे शिखर बनाने के लिए निरपेक्ष मूल्य का उपयोग कर सकते हैं:

 function ridgenoise(nx, ny) { return 2 * (0.5 - abs(0.5 - noise(nx, ny))); } 

ऑक्टेव्स को जोड़ने के लिए, हम उच्च आवृत्तियों के आयाम को भिन्न कर सकते हैं ताकि केवल पहाड़ों को अतिरिक्त शोर प्राप्त हो:

 e0 = 1 * ridgenoise(1 * nx, 1 * ny); e1 = 0.5 * ridgenoise(2 * nx, 2 * ny) * e0; e2 = 0.25 * ridgenoise(4 * nx, 4 * ny) * (e0+e1); e = e0 + e1 + e2; elevation[y][x] = Math.pow(e, exponent); 

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

छतों

यदि हम अगले n स्तरों की ऊँचाई को गोल करते हैं, तो हमें छतें मिलती हैं:


यह e = f(e) रूप में ऊंचाई पुनर्वितरण समारोह को लागू करने का परिणाम है। ऊपर, हमने पर्वत चोटियों को तेज करने के लिए e = Math.pow(e, exponent) का उपयोग किया; यहाँ हम e = Math.round(e * n) / n लिए e = Math.round(e * n) / n का उपयोग करते हैं। यदि आप एक गैर-चरण फ़ंक्शन का उपयोग करते हैं, तो छतों को गोल किया जा सकता है या केवल कुछ ऊंचाइयों पर हो सकता है।

वृक्ष लगाने का स्थान

आमतौर पर हम ऊंचाई और आर्द्रता के लिए भग्न शोर का उपयोग करते थे, लेकिन इसका उपयोग असमान रूप से फैली वस्तुओं, जैसे कि पेड़ों और पत्थरों को रखने के लिए भी किया जा सकता है। ऊंचाई के लिए हम कम आवृत्तियों ("लाल शोर") के साथ उच्च आयाम का उपयोग करते हैं। वस्तुओं को रखने के लिए आपको उच्च आवृत्तियों ("नीला शोर") के साथ उच्च आयामों का उपयोग करने की आवश्यकता होती है। बाईं ओर एक नीला शोर पैटर्न है; दाईं ओर वे स्थान हैं जहां शोर आसन्न मूल्यों से अधिक है:

 for (int yc = 0; yc < height; yc++) { for (int xc = 0; xc < width; xc++) { double max = 0; //     for (int yn = yc - R; yn <= yc + R; yn++) { for (int xn = xc - R; xn <= xc + R; xn++) { double e = value[yn][xn]; if (e > max) { max = e; } } } if (value[yc][xc] == max) { //    xc,yc } } } 

प्रत्येक बायोम के लिए अलग-अलग आर चुनना, हम पेड़ों का एक चर घनत्व प्राप्त कर सकते हैं:



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

अनंत और परे

स्थिति (x, y) पर बायोम की गणना अन्य सभी पदों की गणना से स्वतंत्र है। इस स्थानीय गणना में दो सुविधाजनक गुण हैं: इसे समानांतर में गणना की जा सकती है, और इसका उपयोग अंतहीन इलाके के लिए किया जा सकता है। माउस कर्सर को दाईं ओर का नक्शा बनाने के लिए बाईं ओर मिनिमैप (मूल लेख में) रखें। आप कार्ड के किसी भी हिस्से को जनरेट कर सकते हैं (और स्टोर किए बिना भी) पूरे कार्ड के बिना।

कार्यान्वयन

इलाके उत्पन्न करने के लिए शोर का उपयोग करना एक लोकप्रिय समाधान है, और इंटरनेट पर आप कई अलग-अलग भाषाओं और प्लेटफार्मों के लिए ट्यूटोरियल पा सकते हैं। विभिन्न भाषाओं में कार्ड बनाने का कोड लगभग समान है। यहाँ तीन अलग-अलग भाषाओं में सबसे सरल लूप है:

• जावास्क्रिप्ट:
  
  

   let gen = new SimplexNoise(); function noise(nx, ny) { // Rescale from -1.0:+1.0 to 0.0:1.0 return gen.noise2D(nx, ny) / 2 + 0.5; } let value = []; for (let y = 0; y < height; y++) { value[y] = []; for (let x = 0; x < width; x++) { let nx = x/width - 0.5, ny = y/height - 0.5; value[y][x] = noise(nx, ny); } } 

• C ++:
  
  

   module::Perlin gen; double noise(double nx, double ny) { // Rescale from -1.0:+1.0 to 0.0:1.0 return gen.GetValue(nx, ny, 0) / 2.0 + 0.5; } double value[height][width]; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { double nx = x/width - 0.5, ny = y/height - 0.5; value[y][x] = noise(nx, ny); } } 

• अजगर:
  
  

   from opensimplex import OpenSimplex gen = OpenSimplex() def noise(nx, ny): # Rescale from -1.0:+1.0 to 0.0:1.0 return gen.noise2d(nx, ny) / 2.0 + 0.5 value = [] for y in range(height): value.append([0] * width) for x in range(width): nx = x/width - 0.5 ny = y/height - 0.5 value[y][x] = noise(nx, ny) 

सभी शोर पुस्तकालय बहुत समान हैं। पायथन के लिए ओपनसिम्प्लेक्स आज़माएं, या C ++ के लिए या जावास्क्रिप्ट के लिए सिम्प्लेक्स-नॉइज़ का प्रयोग करें । अधिकांश लोकप्रिय भाषाओं के लिए, कई शोर पुस्तकालय हैं। या आप जान सकते हैं कि पेर्लिन शोर कैसे काम करता है या शोर को खुद महसूस करता है मैंने ऐसा नहीं किया

आपकी भाषा के लिए अलग-अलग शोर पुस्तकालयों में, एप्लिकेशन विवरण थोड़ा भिन्न हो सकता है (0.0 से 1.0 की रेंज में कुछ रिटर्न नंबर, -1.0 से +1.0 की सीमा में अन्य), लेकिन मूल विचार समान है। एक वास्तविक परियोजना के लिए, आपको एक कक्षा में noise फ़ंक्शन और gen ऑब्जेक्ट को लपेटने की आवश्यकता हो सकती है, लेकिन ये विवरण अप्रासंगिक हैं, इसलिए मैंने उन्हें वैश्विक बना दिया।

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

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

प्रयोगों

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


यहाँ एक नमूना कोड है:

 var rng1 = PM_PRNG.create(seed1); var rng2 = PM_PRNG.create(seed2); var gen1 = new SimplexNoise(rng1.nextDouble.bind(rng1)); var gen2 = new SimplexNoise(rng2.nextDouble.bind(rng2)); function noise1(nx, ny) { return gen1.noise2D(nx, ny)/2 + 0.5; } function noise2(nx, ny) { return gen2.noise2D(nx, ny)/2 + 0.5; } for (var y = 0; y < height; y++) { for (var x = 0; x < width; x++) { var nx = x/width - 0.5, ny = y/height - 0.5; var e = (1.00 * noise1( 1 * nx, 1 * ny) + 0.50 * noise1( 2 * nx, 2 * ny) + 0.25 * noise1( 4 * nx, 4 * ny) + 0.13 * noise1( 8 * nx, 8 * ny) + 0.06 * noise1(16 * nx, 16 * ny) + 0.03 * noise1(32 * nx, 32 * ny)); e /= (1.00+0.50+0.25+0.13+0.06+0.03); e = Math.pow(e, 5.00); var m = (1.00 * noise2( 1 * nx, 1 * ny) + 0.75 * noise2( 2 * nx, 2 * ny) + 0.33 * noise2( 4 * nx, 4 * ny) + 0.33 * noise2( 8 * nx, 8 * ny) + 0.33 * noise2(16 * nx, 16 * ny) + 0.50 * noise2(32 * nx, 32 * ny)); m /= (1.00+0.75+0.33+0.33+0.33+0.50); /* draw biome(e, m) at x,y */ } } 

एक कठिनाई है: ऊंचाइयों और आर्द्रता के शोर के लिए एक अलग बीज का उपयोग करना आवश्यक है, अन्यथा वे समान हो जाएंगे, और कार्ड इतने दिलचस्प नहीं दिखेंगे। जावास्क्रिप्ट में, मैं prng-parkmiller लाइब्रेरी का उपयोग करता हूं ; C ++ में, आप दो अलग-अलग रैखिक_संग्रहात्मक_केन वस्तुओं का उपयोग कर सकते हैं; पायथन में, आप एक रैंडम रैंडम क्लास के दो अलग-अलग उदाहरण बना सकते हैं।

विचारों

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

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

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

अतिरिक्त जानकारी

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

यह परियोजना मेरी पिछली मानचित्र पीढ़ी परियोजनाओं से प्रभावित थी:

• मैंने मैड गॉड कार्ड जनरेटर के अपने पहले दायरे के लिए पेरलिन के समग्र शोर का इस्तेमाल किया। हमने इसे अल्फा परीक्षण के पहले छह महीनों के लिए उपयोग किया, और फिर इसे वोरोनोई पॉलीगोन पर एक मैप जनरेटर के साथ बदल दिया, विशेष रूप से उन गेमप्ले आवश्यकताओं के लिए बनाया जो हमने अल्फा परीक्षण के दौरान निर्धारित किए थे। लेख के लिए बायोम और उनके रंग इन परियोजनाओं से लिए गए हैं।
• ऑडियो सिग्नल के प्रसंस्करण का अध्ययन करते समय, मैंने एक शोर ट्यूटोरियल लिखा, जो आवृत्ति, आयाम, ऑक्टेव्स और शोर के "रंग" जैसी अवधारणाओं की व्याख्या करता है। ध्वनि के लिए काम करने वाली वही अवधारणाएं शोर-आधारित कार्ड पीढ़ी पर भी लागू होती हैं। उस समय, मैंने कुछ कच्चे डेमो रिलीफ जनरेशन बनाए, लेकिन मैंने उन्हें खत्म नहीं किया।
• कभी-कभी मैं सीमाओं को खोजने के लिए प्रयोग करता हूं। मैं यह जानना चाहता था कि सम्मोहक मानचित्र बनाने के लिए कोड की न्यूनतम आवश्यकता कितनी है। इस मिनी-प्रोजेक्ट में, मैं कोड की शून्य लाइनों तक पहुंच गया - सब कुछ छवि फिल्टर (अशांति, थ्रेसहोल्ड, रंग ढ़ाल) के साथ किया जाता है। इससे मुझे खुशी और दुख हुआ। छवि फिल्टर द्वारा पीढ़ी का मानचित्र किस हद तक किया जा सकता है? काफी बड़े में। "सुचारू रंग ग्रेडिएंट्स की योजना" के बारे में ऊपर वर्णित सब कुछ इस प्रयोग से लिया गया है। शोर परत एक अशांति छवि फिल्टर है; सप्तक एक दूसरे पर आरोपित चित्र हैं; फोटोशॉप में डिग्री टूल को "कर्व करेक्शन" कहा जाता है।

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

कई और चीजें हैं जो शोर के साथ की जा सकती हैं, लेख में मैंने केवल कुछ का उल्लेख किया है। संवादात्मक रूप से विभिन्न विशेषताओं का परीक्षण करने के लिए शोर स्टूडियो का प्रयास करें।