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

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

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

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

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

 terraintree =
 {
	 {name = "ground_gradient", टाइप = "ग्रेडिएंट", X1 = ०, x2 = ०, y1 = ०, y2 = १}
 } 

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

2 डी के मामले में, ग्रेडिएंट फ़ंक्शन फॉर्म (X1, x2, y1, y2) में एक सीधी रेखा खंड प्राप्त करता है, और 3D के मामले में, प्रारूप को (X1, x2, y1, y2, z1, z2) तक विस्तारित किया जाता है। बिंदु (X1, y1) द्वारा गठित बिंदु खंड मैप की शुरुआत को 0. दर्शाता है। गठित बिंदु (x2, y2) खंड के अंत में मैप किया गया है। 1. यह है, यहाँ हम लाइन खंड (0,1)> मैप करते हैं। 0,0) एक ढाल के साथ। इसलिए, ढाल वाई = 1 और वाई = 0 फ़ंक्शन के क्षेत्रों के बीच होगा। यही है, यह पट्टी वाई में दुनिया के आयाम बनाती है। दुनिया का कोई भी हिस्सा इस पट्टी में होगा। हम एक्स के साथ किसी भी क्षेत्र को स्नैप कर सकते हैं (लगभग विज्ञापन infinitum, लेकिन यहां double परिशुद्धता हमें सीमित करती है), लेकिन सब कुछ दिलचस्प है, अर्थात पृथ्वी की सतह इस बैंड के भीतर होगी। इस व्यवहार को बदला जा सकता है, लेकिन इसके भीतर हमारे पास काफी हद तक लचीलापन है। बस यह मत भूलो कि इस बैंड के ऊपर या नीचे होने वाले किसी भी मान के निर्बाध होने की सबसे अधिक संभावना है, क्योंकि ऊपर दिए गए मूल्य हवा होने की सबसे अधिक संभावना है, और नीचे दिए गए मूल्य जमीन हैं। (जैसा कि आप जल्द ही देखेंगे, यह कथन अच्छी तरह से गलत हो सकता है।) इस श्रृंखला की अधिकांश छवियों के लिए, मैं 2 डी स्थान में वर्ग (0,1) -> (1,0) द्वारा दिए गए वर्ग क्षेत्र से मेल खाऊंगा। इसलिए, शुरुआत में हमारी दुनिया इस तरह दिखती है:


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

 terraintree =
 {
	 {name = "ground_gradient", टाइप = "ग्रेडिएंट", X1 = ०, x2 = ०, y1 = ०, y2 = १},
	 {name = "ground_select", प्रकार = "चयन", निम्न = ०, उच्च = १, दहलीज = ०.५, नियंत्रण = "ground_gradient"}
 }

फंक्शन के उसी क्षेत्र की तुलना पहले की तरह करें, हमें कुछ समान मिलता है:


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

"टर्बुलेंस" एक फ़ंक्शन के आने वाले निर्देशांक में मूल्यों को जोड़ने की अवधारणा का एक जटिल पदनाम है। कल्पना करें कि हम पृथ्वी के उपरोक्त कार्य को समन्वय (0,1) के साथ कहते हैं। यह ग्राउंड प्लेन के ऊपर होता है, क्योंकि Y = 1 में ग्रेडिएंट का मान 0 होता है, जो थ्रेसहोल्ड = 0.5 से कम है। यही है, इस बिंदु की गणना ओपन के रूप में की जाएगी। लेकिन क्या होगा अगर, पृथ्वी के कार्य को शुरू करने से पहले, हम किसी तरह इस बिंदु को बदल दें? मान लीजिए कि हम Y निर्देशांक से एक यादृच्छिक मूल्य घटाते हैं, उदाहरण के लिए, 3. हम 3 घटाते हैं और समन्वय प्राप्त करते हैं (0, -2)। यदि हम अब इस बिंदु के लिए जमीन फ़ंक्शन कहते हैं, तो बिंदु को ठोस माना जाएगा, क्योंकि Y = -2 ग्रेडिएंट सेगमेंट के नीचे 1 के बराबर है। अचानक, खोखला बिंदु (0,1) एक ठोस में बदल जाता है। हमें हवा में लटके हुए ठोस पत्थर का एक ब्लॉक मिलेगा। यह ग्राउंड_सेलेक्ट फ़ंक्शन को कॉल करने से पहले आने वाले बिंदु के वाई समन्वय से एक यादृच्छिक संख्या को जोड़कर या घटाकर फ़ंक्शन के किसी भी बिंदु के साथ किया जा सकता है। यहां ग्राउंड_सेलेक्ट फंक्शन की एक छवि यह दिखा रही है। ग्राउंड_सेलेक्ट फ़ंक्शन को कॉल करने से पहले, प्रत्येक बिंदु के वाई समन्वय में अंतराल (-0.25, 0.25) में मूल्य जोड़ा जाता है।


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

 terraintree =
 {
	 {name = "ground_gradient", टाइप = "ग्रेडिएंट", X1 = ०, x2 = ०, y1 = ०, y2 = १},
	 {name = "ground_shape_fractal", टाइप = "फ्रैक्टल", फ्रैक्टालाइप = anl.FBM, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, अष्टक: ६, आवृत्ति = २},
	 {name = "ground_scale", टाइप = "स्केलऑफ़सेट", स्केल = 0.5, ऑफसेट = 0, स्रोत = "ground_shape_fractal"},
	 {name = "ground_perturb", टाइप = "अनूदित", स्रोत = "ग्राउंड_ग्रेडिएंट", ty = "ground_scale"}
	
	 {name = "ground_select", प्रकार = "चयन", निम्न = ०, उच्च = १, दहलीज = ०.५, नियंत्रण = "ground_perturb"}
 }

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


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


ऊपर की छवि में, सभी काले बिंदुओं का मान -0.25 है, और सभी सफेद बिंदुओं का मान 0.25 है। यही है, जहां भग्न काला है, पृथ्वी के कार्य के संबंधित बिंदु को 0.25 से "नीचे" स्थानांतरित किया जाएगा। (स्क्रीन का 0.25 का अर्थ 1/4 है।) चूंकि एक बिंदु को थोड़ा स्थानांतरित किया जा सकता है, और अंतरिक्ष में इसके ऊपर के दूसरे बिंदु को अधिक स्थानांतरित किया जा सकता है, चट्टानों और उड़ान द्वीपों के फैलाव की संभावना है। उड़ान द्वीपों के विपरीत, प्रकृति में फैलाव काफी स्वाभाविक है। (जब तक हम फिल्म "अवतार" में नहीं हैं) यदि आपके गेम को इस तरह के शानदार परिदृश्य की आवश्यकता है, तो यह बहुत अच्छा है, लेकिन यदि आपको अधिक यथार्थवादी मॉडल की आवश्यकता है, तो हमें फ्रैक्टल फ़ंक्शन को थोड़ा समायोजित करने की आवश्यकता है। सौभाग्य से, स्केलडोमेन फ़ंक्शन ऐसा कर सकता है।

हम फ़ंक्शन को एक ऊंचाई मानचित्र फ़ंक्शन की तरह व्यवहार करना चाहते हैं। एक 2 डी ऊंचाई के नक्शे की कल्पना करें जहां मानचित्र पर प्रत्येक बिंदु ग्रिड बिंदुओं की ग्रिड में एक बिंदु की ऊंचाई का प्रतिनिधित्व करता है जो ऊपर या नीचे उठाए जाते हैं। नक्शे के सफेद मूल्य उच्च पहाड़ियों, काली - निम्न घाटियों को दर्शाते हैं। हमें समान व्यवहार की आवश्यकता है, लेकिन इसे प्राप्त करने के लिए, हमें अनिवार्य रूप से एक आयाम से छुटकारा पाने की आवश्यकता है। ऊंचाई के नक्शे के मामले में, हम 2 डी ऊंचाई के नक्शे से 3 डी ऊंचाई बनाते हैं। इसी तरह, 2 डी इलाके के मामले में, हमें 1 डी ऊंचाई के नक्शे की आवश्यकता है। ऐसा करने से कि एक ही Y निर्देशांक वाले एक भग्न के सभी बिंदुओं का समान मूल्य होता है, हम सभी बिंदुओं को एक ही X के साथ एक ही राशि द्वारा समन्वयित कर सकते हैं, इसलिए उड़ान द्वीप गायब हो जाते हैं। ऐसा करने के लिए, आप स्केल गुणांक को रीसेट करते हुए स्केलडोमैन का उपयोग कर सकते हैं। यही है, ग्राउंड_शैप_फ्रैक्टल फ़ंक्शन को कॉल करने से पहले, हम y को समन्वयित करने के लिए ग्राउंड_काले_यंत्र को 0. पर कॉल करते हैं। यह सुनिश्चित करता है कि वाई मूल्य फ्रैक्टल के आउटपुट को प्रभावित नहीं करता है, अनिवार्य रूप से इसे 1 डी शोर फ़ंक्शन में बदल देता है। ऐसा करने के लिए, हम निम्नलिखित बदलाव करेंगे:

 terraintree =
 {
	 {name = "ground_gradient", टाइप = "ग्रेडिएंट", X1 = ०, x2 = ०, y1 = ०, y2 = १},
	 {name = "ground_shape_fractal", टाइप = "फ्रैक्टल", फ्रैक्टालाइप = anl.FBM, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, अष्टक: ६, आवृत्ति = २},
	 {name = "ground_scale", टाइप = "स्केलऑफ़सेट", स्केल = 0.5, ऑफसेट = 0, स्रोत = "ground_shape_fractal"},
	 {name = "ground_scale_y", टाइप = "स्केलडोमैन", स्रोत = "ग्राउंड_कैसल", स्केल = 0},
	 {name = "ground_perturb", प्रकार = "अनुवादित", स्रोत = "ग्राउंड_ग्रेडिएंट", ty = "ground_scale_y"},
	
	 {name = "ground_select", प्रकार = "चयन", निम्न = ०, उच्च = १, दहलीज = ०.५, नियंत्रण = "ground_perturb"}
 }

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


अब यदि हम आउटपुट पर एक नज़र डालते हैं, तो हमें इसका परिणाम मिलता है:


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

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

 terraintree =
 {
	 {name = "ground_gradient", टाइप = "ग्रेडिएंट", X1 = ०, x2 = ०, y1 = ०, y2 = १},
	 {name = "ground_shape_fractal", टाइप = "फ्रैक्टल", फ्रैक्टालाइप = anl.FBM, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, अष्टक: ६, आवृत्ति = २},
	 {name = "ground_scale", टाइप = "स्केलऑफ़सेट", स्केल = 0.5, ऑफसेट = 0, स्रोत = "ground_shape_fractal"},
	 {name = "ground_scale_y", टाइप = "स्केलडोमैन", स्रोत = "ग्राउंड_कैसल", स्केल = 0},
	 {name = "ground_perturb", प्रकार = "अनुवादित", स्रोत = "ग्राउंड_ग्रेडिएंट", ty = "ground_scale_y"},
	 {name = "ground_overhang_fractal", टाइप = "फ्रैक्टल", फ्रैक्टलाइप = anl.FBM, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, अष्टक: ६, आवृत्ति = २},
	 {name = "ground_overhang_scale", प्रकार = "स्केलऑफ़सेट", स्रोत = "ground_overhang_fractal", स्केल = 0.2, ऑफसेट = 0},
	 {name = "ground_overhang_perturb", प्रकार = "अनुवादित", स्रोत = "ground_perturb", tx = "ground_overhang_scale"}
	
	 {name = "ground_select", प्रकार = "चयन", निम्न = ०, उच्च = १, दहलीज = ०.५, नियंत्रण = "ground_overhang_perturb"}
 }

और यहाँ परिणाम है:


दूसरा तरीका: आप ग्राउंड_केले_य फ़ंक्शन के स्केल पैरामीटर को 0. से अधिक मान पर सेट कर सकते हैं। यदि आप वाई में एक छोटा स्केल छोड़ते हैं, तो हम परिवर्तनशीलता का एक अंश प्राप्त करेंगे, हालांकि, जितना बड़ा स्केल होगा, राहत स्केलिंग के बिना पिछले संस्करण से अधिक मजबूत होगी।


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

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

सिद्धांत को स्पष्ट करने के लिए, हम तीन प्रकार की राहत में अंतर करते हैं: पठार (चिकनी ढलान वाली पहाड़ियाँ), पहाड़ और तराई (ज्यादातर सपाट)। उनके बीच स्विच करने के लिए, हम एक चयन-आधारित प्रणाली का उपयोग करते हैं और उन्हें एक जटिल कैनवास में जोड़ते हैं। तो यहाँ हम चलते हैं ...

तलहटी:

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

 {name = "lowland_shape_fractal", टाइप = "फ्रैक्टल", फ्रैक्टालाइप = anl.FBM, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, ऑक्टेवस: २, आवृत्ति = १},
 {name = "lowland_autocorrect", type = "autocorrect", source = "lowland_shape_fractal", low = 0, high = 1},
 {name = "lowland_scale", टाइप = "स्केलऑफ़सेट", स्रोत = "lowland_autocorrect", स्केल = 0.2, ऑफसेट = -0.25}, आदि
 {name = "lowland_y_scale", प्रकार = "स्केलडोनैन", स्रोत = "तराई_काले", पैमाने = 0},
 {name = "lowland_terrain", प्रकार = "अनुवादित", स्रोत = "ग्राउंड_ग्रेडिएंट", ty = "lowland_y_scale"},

पठार:

उनके साथ, भी, सब कुछ सरल है। (वास्तव में, इन इलाकों में से कोई भी प्रकार मुश्किल नहीं है।) हालांकि, हम पहाड़ियों को टीलों की तरह बनाने के लिए एक अलग आधार का उपयोग करते हैं।

 {name = "highland_shape_fractal", टाइप = "फ्रैक्टल", फ्रैक्टालाइप = anl.RIDGEDMULTI, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUADIC, अष्टक = २, आवृत्ति = २}।
 {name = "highland_autocorrect", type = "autocorrect", source = "highland_shape_fractal", low = 0, high = 1},
 {name = "highland_scale", प्रकार = "स्केलऑफ़सेट", स्रोत = "highland_autocorrect", स्केल = ०.४५, ऑफसेट = ०},
 {name = "highland_y_scale", टाइप = "स्केलडनैन", स्रोत = "हाईलैंड_कैसल", स्केल = ०},
 {name = "highland_terrain", प्रकार = "अनुवादित", स्रोत = "ग्राउंड_ग्रेडिएंट", ty = "हाईलैंड_y_scale"},

पहाड़:

 {name = "Mountain_shape_fractal", टाइप = "फ्रैक्टल", फ्रैक्टलाइप = anl.BILLOW, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, अष्टक = ४, आवृत्ति = १},
 {name = "Mountain_autocorrect", type = "autocorrect", source = "Mountain_shape_fractal", low = 0, high = 1},
 {name = "Mountain_scale", टाइप = "स्केलऑफ़सेट", सोर्स = "माउंटेन_ऑटोकोरेट", स्केल = ०. ,५, ऑफसेट = ०.२५},
 {name = "Mountain_y_scale", टाइप = "स्केलडनैन", सोर्स = "माउंटेन_कैसल", स्केल = 0.1},
 {name = "Mountain_terrain", प्रकार = "अनुवादित", स्रोत = "ग्राउंड_ग्रेडिएंट", ty = "पर्वत_y_scale"},

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

 {name = "terrain_type_fractal", प्रकार = "भग्न", fractaltype = anl.FBM, basistype = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, ओक्टेवेस: ३, आवृत्ति = ०.५},
 {name = "terrain_autocorrect", type = "autocorrect", source = "terrain_type_fractal", low = 0, high = 1},
 {name = "terrain_type_cache", टाइप करें = "cache", स्रोत = "terrain_autocorrovo", "
 {name = "हाइलैंड_माउंट_सेलेक्ट", टाइप = "सिलेक्ट", लो = "हाइलैंड_ट्रेन", हाई = "माउंटेन_ट्रेन", कंट्रोल = "टेरीन_टाइप_कैशे", थ्रेशोल्ड = ०.५५, फॉलऑफ = ०.१५},
 {name = "highland_lowland_select", type = "select", low = "lowland_terrain", high = "highland_mountain_select", control = "terrain_type_cache", थ्रेशोल्ड = ०.२५, फॉलऑफ = ०.१५},

तो, यहाँ हम तीन मुख्य प्रकार के इलाकों को परिभाषित करते हैं: तराई, उच्चभूमि और पहाड़। हम उनमें से एक का चयन करने के लिए एक भग्न का उपयोग करते हैं, ताकि प्राकृतिक संक्रमण (तराई-> हाइलैंड्स-> पहाड़) हो। फिर हम मानचित्र में बैडलैंड को बेतरतीब ढंग से सम्मिलित करने के लिए एक और भग्न का उपयोग करते हैं। यहां बताया गया है कि समाप्त मॉड्यूल श्रृंखला क्या दिखती है:

 terraintree =
 {
	 {name = "lowland_shape_fractal", टाइप = "फ्रैक्टल", फ्रैक्टालाइप = anl.FBM, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, ऑक्टेवस: २, आवृत्ति = १},
	 {name = "lowland_autocorrect", type = "autocorrect", source = "lowland_shape_fractal", low = 0, high = 1},
	 {name = "lowland_scale", टाइप = "स्केलऑफ़सेट", स्रोत = "lowland_autocorrect", स्केल = 0.2, ऑफसेट = -0.25}, आदि
	 {name = "lowland_y_scale", प्रकार = "स्केलडोनैन", स्रोत = "तराई_काले", पैमाने = 0},
	 {name = "lowland_terrain", प्रकार = "अनुवादित", स्रोत = "ग्राउंड_ग्रेडिएंट", ty = "lowland_y_scale"},
	 {name = "ground_gradient", टाइप = "ग्रेडिएंट", X1 = ०, x2 = ०, y1 = ०, y2 = १},
	 {name = "highland_shape_fractal", टाइप = "फ्रैक्टल", फ्रैक्टालाइप = anl.RIDGEDMULTI, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUADIC, अष्टक = २, आवृत्ति = २}।
	 {name = "highland_autocorrect", type = "autocorrect", source = "highland_shape_fractal", low = 0, high = 1},
	 {name = "highland_scale", प्रकार = "स्केलऑफ़सेट", स्रोत = "highland_autocorrect", स्केल = ०.४५, ऑफसेट = ०},
	 {name = "highland_y_scale", टाइप = "स्केलडनैन", स्रोत = "हाईलैंड_कैसल", स्केल = ०},
	 {name = "highland_terrain", प्रकार = "अनुवादित", स्रोत = "ग्राउंड_ग्रेडिएंट", ty = "हाईलैंड_y_scale"},

	 {name = "Mountain_shape_fractal", टाइप = "फ्रैक्टल", फ्रैक्टलाइप = anl.BILLOW, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, अष्टक = ४, आवृत्ति = १},
	 {name = "Mountain_autocorrect", type = "autocorrect", source = "Mountain_shape_fractal", low = 0, high = 1},
	 {name = "Mountain_scale", टाइप = "स्केलऑफ़सेट", सोर्स = "माउंटेन_ऑटोकोरेट", स्केल = ०. ,५, ऑफसेट = ०.२५},
	 {name = "Mountain_y_scale", टाइप = "स्केलडनैन", सोर्स = "माउंटेन_कैसल", स्केल = 0.1},
	 {name = "Mountain_terrain", प्रकार = "अनुवादित", स्रोत = "ग्राउंड_ग्रेडिएंट", ty = "पर्वत_y_scale"},

	 {name = "terrain_type_fractal", प्रकार = "भग्न", fractaltype = anl.FBM, basistype = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, ओक्टेवेस: ३, आवृत्ति = ०.५},
	 {name = "terrain_autocorrect", type = "autocorrect", source = "terrain_type_fractal", low = 0, high = 1},
	 {name = "terrain_type_cache", टाइप करें = "cache", स्रोत = "terrain_autocorrovo", "
	 {name = "highland_mountain_select", टाइप = "select", low = "highland_terrain", उच्च = "Mountain_terrain", नियंत्रण = "terrain_type_cache", थ्रेशोल्ड = ०.५५, फॉलऑफ = ०.१५},
	 {name = "highland_lowland_select", type = "select", low = "lowland_terrain", high = "highland_mountain_select", control = "terrain_type_cache", थ्रेशोल्ड = ०.२५, फॉलऑफ = ०.१५},
	 {name = "ground_select", प्रकार = "चयन", निम्न = ०, उच्च = १, दहलीज = ०.५, नियंत्रण = "highland_lowland_select"}
 }

परिणामी राहत के कुछ उदाहरण इस प्रकार हैं:




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

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

 {name = "cave_shape", टाइप = "फ्रैक्टल", फ्रैक्टालाइप = anl.RIDGEDMULTI, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, ऑक्टाकोर = १, आवृत्ति = २},

परिणाम कुछ इस प्रकार है:


यदि हम चयन फ़ंक्शन को एक टुकड़ा-परिभाषित-परिभाषित फ़ंक्शन के रूप में लागू करते हैं, जैसा कि हमने पृथ्वी ढाल के साथ किया था, तो इसे लागू करना ताकि चयन सीमा का निचला भाग 1 (कोई गुफा नहीं है), और ऊपरी भाग 0 है (एक गुफा है, परिणाम कुछ इस तरह दिखेगा। :

 {name = "cave_shape", टाइप = "फ्रैक्टल", फ्रैक्टालाइप = anl.RIDGEDMULTI, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, ऑक्टाकोर = १, आवृत्ति = २},
 {name = "cave_select", type = "select", low = 1, high = 0, control = "cave_shape", थ्रेशोल्ड = ०.ave, फॉलॉफ़ = ०}।

परिणाम:


बेशक, यह बहुत चिकनी लग रहा है, इसलिए क्षेत्र को विकृत करने के लिए कुछ भग्न शोर जोड़ें।

 {name = "cave_shape", टाइप = "फ्रैक्टल", फ्रैक्टालाइप = anl.RIDGEDMULTI, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, ऑक्टाकोर = १, आवृत्ति = २},
 {name = "cave_select", type = "select", low = 1, high = 0, control = "cave_shape", थ्रेशोल्ड = ०.ave, फॉलॉफ़ = ०}।
 {name = "cave_perturb_fractal", टाइप = "फ्रैक्टल", फ्रैक्टलाइप = anl.FBM, बेसिस्टाइप = anl.GRADIENT, इंटरप्टाइप = anl.QUINTIC, ऑक्टा = ६, आवृत्ति = ३},
 {name = "cave_perturb_scale", type = "scaleoffset", source = "cave_perturb_fractal", स्केल = 0.25, ऑफसेट = 0},
{name = "cave_perturb", टाइप = "अनूदित", स्रोत = "cave_select", tx = "cave_perturb_scale"},

परिणाम:


यह गुफाओं को थोड़ा शोर करता है और उन्हें इतना चिकना नहीं बनाता है। आइए अब देखें कि यदि आप गुफाओं को राहत के लिए लागू करते हैं तो क्या होता है:


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

{name="highland_lowland_select", type="select", low="lowland_terrain", high="highland_mountain_select", control="terrain_type_cache", threshold=0.25, falloff=0.15},
{name="highland_lowland_select_cache", type="cache", source="highland_lowland_select"},
{name="ground_select", type="select", low=0, high=1, threshold=0.5, control="highland_lowland_select_cache"},

Cache, ground_select , , . , :

{name="cave_shape", type="fractal", fractaltype=anl.RIDGEDMULTI, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=1, frequency=4},
{name="cave_attenuate_bias", type="bias", source="highland_lowland_select_cache", bias=0.45},
{name="cave_shape_attenuate", type="combiner", operation=anl.MULT, source_0="cave_shape", source_1="cave_attenuate_bias"},
{name="cave_perturb_fractal", type="fractal", fractaltype=anl.FBM, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=6, frequency=3},
{name="cave_perturb_scale", type="scaleoffset", source="cave_perturb_fractal", scale=0.5, offset=0},
{name="cave_perturb", type="translatedomain", source="cave_shape_attenuate", tx="cave_perturb_scale"},
{name="cave_select", type="select", low=1, high=0, control="cave_perturb", threshold=0.48, falloff=0},

सबसे पहले, हमने बायस फ़ंक्शन को जोड़ा । यह सुविधा के लिए है, क्योंकि यह हमें ढाल क्षीणन समारोह के अंतराल को समायोजित करने की अनुमति देता है। तब समारोह जोड़ा cave_shape_attenuate , जो है Combiner प्रकार anl :: MULT । वह cave_shape द्वारा ढाल को गुणा करती है । फिर इस ऑपरेशन का परिणाम cave_perturb फ़ंक्शन को दिया जाता है । परिणाम कुछ इस तरह दिखता है:


, . ( , , . — , - , (0,1).) , , , , . , .

terraintree=
 {
	{name="ground_gradient", type="gradient", x1=0, x2=0, y1=0, y2=1},
	
	{name="lowland_shape_fractal", type="fractal", fractaltype=anl.BILLOW, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=2, frequency=0.25},
	{name="lowland_autocorrect", type="autocorrect", source="lowland_shape_fractal", low=0, high=1},
	{name="lowland_scale", type="scaleoffset", source="lowland_autocorrect", scale=0.125, offset=-0.45},
	{name="lowland_y_scale", type="scaledomain", source="lowland_scale", scaley=0},
	{name="lowland_terrain", type="translatedomain", source="ground_gradient", ty="lowland_y_scale"},
	
	{name="highland_shape_fractal", type="fractal", fractaltype=anl.FBM, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=4, frequency=2},
	{name="highland_autocorrect", type="autocorrect", source="highland_shape_fractal", low=-1, high=1},
	{name="highland_scale", type="scaleoffset", source="highland_autocorrect", scale=0.25, offset=0},
	{name="highland_y_scale", type="scaledomain", source="highland_scale", scaley=0},
	{name="highland_terrain", type="translatedomain", source="ground_gradient", ty="highland_y_scale"},

	{name="mountain_shape_fractal", type="fractal", fractaltype=anl.RIDGEDMULTI, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=8, frequency=1},
	{name="mountain_autocorrect", type="autocorrect", source="mountain_shape_fractal", low=-1, high=1},
	{name="mountain_scale", type="scaleoffset", source="mountain_autocorrect", scale=0.45, offset=0.15},
	{name="mountain_y_scale", type="scaledomain", source="mountain_scale", scaley=0.25},
	{name="mountain_terrain", type="translatedomain", source="ground_gradient", ty="mountain_y_scale"},

	{name="terrain_type_fractal", type="fractal", fractaltype=anl.FBM, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=3, frequency=0.125},
	{name="terrain_autocorrect", type="autocorrect", source="terrain_type_fractal", low=0, high=1},
	{name="terrain_type_y_scale", type="scaledomain", source="terrain_autocorrect", scaley=0},
	{name="terrain_type_cache", type="cache", source="terrain_type_y_scale"},
	{name="highland_mountain_select", type="select", low="highland_terrain", high="mountain_terrain", control="terrain_type_cache", threshold=0.55, falloff=0.2},
	{name="highland_lowland_select", type="select", low="lowland_terrain", high="highland_mountain_select", control="terrain_type_cache", threshold=0.25, falloff=0.15},
	{name="highland_lowland_select_cache", type="cache", source="highland_lowland_select"},
	{name="ground_select", type="select", low=0, high=1, threshold=0.5, control="highland_lowland_select_cache"},
	
	{name="cave_shape", type="fractal", fractaltype=anl.RIDGEDMULTI, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=1, frequency=4},
	{name="cave_attenuate_bias", type="bias", source="highland_lowland_select_cache", bias=0.45},
	{name="cave_shape_attenuate", type="combiner", operation=anl.MULT, source_0="cave_shape", source_1="cave_attenuate_bias"},
	{name="cave_perturb_fractal", type="fractal", fractaltype=anl.FBM, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=6, frequency=3},
	{name="cave_perturb_scale", type="scaleoffset", source="cave_perturb_fractal", scale=0.5, offset=0},
	{name="cave_perturb", type="translatedomain", source="cave_shape_attenuate", tx="cave_perturb_scale"},
	{name="cave_select", type="select", low=1, high=0, control="cave_perturb", threshold=0.48, falloff=0},
	
	{name = "ground_cave_multiply", टाइप = "कॉम्बिनर", ऑपरेशन = anl.MULT, source_0 = "cave_select", source_1 = "ground_select"}
 }

इस समारोह से प्राप्त रैंडमाइज्ड कार्ड के उदाहरण इस प्रकार हैं:




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

आप इस प्रणाली को कई अलग-अलग तरीकों से बदल सकते हैं, अलग-अलग परिणाम प्राप्त कर सकते हैं। हम सीमा की सेटिंग बदल सकते cave_select में और मानकों cave_attenuate_bias , या बदलने के cave_attenuate_biasअन्य कार्यों को अन्य मूल्यों के लिए ढाल अंतराल से मेल खाना है जो आपकी आवश्यकताओं के अनुरूप बेहतर हैं। आप एक्स अक्ष के साथ अस्वाभाविक रूप से चिकनी सुरंगों की संभावना को समाप्त करने के लिए वाई अक्ष के साथ गुफा प्रणाली को विकृत करने वाले एक और भग्न को भी जोड़ सकते हैं (इस तथ्य के कारण कि गुफा का आकार केवल एक्स अक्ष के साथ विकृत है)। आप क्षीणन के एक अतिरिक्त स्रोत के रूप में एक नया फ्रैक्टल भी जोड़ सकते हैं , cave_shape_attenuate के लिए एक तीसरा स्रोत निर्दिष्ट करते हैं , जो क्षेत्रों के आधार पर क्षीणन को मापता है, ताकि कुछ क्षेत्रों में गुफाएं घनी हो जाएं (उदाहरण के लिए, पहाड़ों में), और कम अक्सर या दूसरों में पूरी तरह से अनुपस्थित। यह क्षेत्रीय चयन terrain_type_fractal फ़ंक्शन से बनाया जा सकता हैयह जानने के लिए कि पर्वतीय क्षेत्र कहाँ स्थित हैं। यह सब आप क्या चाहते हैं, यह सोचने के लिए नीचे आता है कि आउटपुट पर विभिन्न कार्यों का क्या प्रभाव पड़ेगा, और जब तक आप वांछित परिणाम प्राप्त नहीं करते, मापदंडों के साथ प्रयोग करते हैं। यह एक सटीक विज्ञान नहीं है, और अक्सर वांछित प्रभाव को विभिन्न तरीकों से पहुँचा जा सकता है।

कमियों

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

3 डी पर जाएं

यह सब बहुत अच्छा है यदि आप टेरारिया या किंग आर्थर गोल्ड जैसे गेम बनाते हैं , लेकिन अगर आपको Minecraft या Infiniminer जैसी किसी चीज़ की ज़रूरत है, तो क्या होगा ? ? , . 3D-. 3D-, 3D- , Y , 2D-. - , , . , Ridged Multifractal 2D- , 3D , , . 3D , 1- Ridged Multifractal, seed. Select 1 0, . , , , , .

terraintree3d=
 {
	{name="ground_gradient", type="gradient", x1=0, x2=0, y1=0, y2=1},
	
	{name="lowland_shape_fractal", type="fractal", fractaltype=anl.BILLOW, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=2, frequency=0.25},
	{name="lowland_autocorrect", type="autocorrect", source="lowland_shape_fractal", low=0, high=1},
	{name="lowland_scale", type="scaleoffset", source="lowland_autocorrect", scale=0.125, offset=-0.45},
	{name="lowland_y_scale", type="scaledomain", source="lowland_scale", scaley=0},
	{name="lowland_terrain", type="translatedomain", source="ground_gradient", ty="lowland_y_scale"},
	
	{name="highland_shape_fractal", type="fractal", fractaltype=anl.FBM, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=4, frequency=2},
	{name="highland_autocorrect", type="autocorrect", source="highland_shape_fractal", low=-1, high=1},
	{name="highland_scale", type="scaleoffset", source="highland_autocorrect", scale=0.25, offset=0},
	{name="highland_y_scale", type="scaledomain", source="highland_scale", scaley=0},
	{name="highland_terrain", type="translatedomain", source="ground_gradient", ty="highland_y_scale"},

	{name="mountain_shape_fractal", type="fractal", fractaltype=anl.RIDGEDMULTI, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=8, frequency=1},
	{name="mountain_autocorrect", type="autocorrect", source="mountain_shape_fractal", low=-1, high=1},
	{name="mountain_scale", type="scaleoffset", source="mountain_autocorrect", scale=0.45, offset=0.15},
	{name="mountain_y_scale", type="scaledomain", source="mountain_scale", scaley=0.25},
	{name="mountain_terrain", type="translatedomain", source="ground_gradient", ty="mountain_y_scale"},

	{name="terrain_type_fractal", type="fractal", fractaltype=anl.FBM, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=3, frequency=0.125},
	{name="terrain_autocorrect", type="autocorrect", source="terrain_type_fractal", low=0, high=1},
	{name="terrain_type_y_scale", type="scaledomain", source="terrain_autocorrect", scaley=0},
	{name="terrain_type_cache", type="cache", source="terrain_type_y_scale"},
	{name="highland_mountain_select", type="select", low="highland_terrain", high="mountain_terrain", control="terrain_type_cache", threshold=0.55, falloff=0.2},
	{name="highland_lowland_select", type="select", low="lowland_terrain", high="highland_mountain_select", control="terrain_type_cache", threshold=0.25, falloff=0.15},
	{name="highland_lowland_select_cache", type="cache", source="highland_lowland_select"},
	{name="ground_select", type="select", low=0, high=1, threshold=0.5, control="highland_lowland_select_cache"},
	
	{name="cave_attenuate_bias", type="bias", source="highland_lowland_select_cache", bias=0.45},
	{name="cave_shape1", type="fractal", fractaltype=anl.RIDGEDMULTI, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=1, frequency=4},
	{name="cave_shape2", type="fractal", fractaltype=anl.RIDGEDMULTI, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=1, frequency=4},
	{name="cave_shape_attenuate", type="combiner", operation=anl.MULT, source_0="cave_shape1", source_1="cave_attenuate_bias", source_2="cave_shape2"},             
	{name="cave_perturb_fractal", type="fractal", fractaltype=anl.FBM, basistype=anl.GRADIENT, interptype=anl.QUINTIC, octaves=6, frequency=3},
	{name="cave_perturb_scale", type="scaleoffset", source="cave_perturb_fractal", scale=0.5, offset=0},
	{name="cave_perturb", type="translatedomain", source="cave_shape_attenuate", tx="cave_perturb_scale"},
	{name="cave_select", type="select", low=1, high=0, control="cave_perturb", threshold=0.48, falloff=0},
	
	{name="ground_cave_multiply", type="combiner", operation=anl.MULT, source_0="cave_select", source_1="ground_select"}
 }

:



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