🤕 ☺️ 🛌🏿 यादृच्छिक दो-आयामी गुफा जनरेटर 🌅 ⚓️ 🍿

प्रस्तावना

यदि आप अपने समय का ध्यान रखने के ~~लिए~~ बहुत ~~आलसी~~ हैं, अपने खेल के लिए एक स्तर बना रहे हैं, तो आप सही जगह पर आए हैं।

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

लेख पढ़ने के अंत में, आपको कुछ इस तरह मिलना चाहिए:

परिणाम

सिद्धांत

पहाड़

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

गुफा

खुद को काल कोठरी उत्पन्न करने के लिए, मैंने चुना - जैसा कि मुझे लगता है - एक उत्कृष्ट एल्गोरिथ्म। सरल शब्दों में, इसे निम्नानुसार समझाया जा सकता है: भले ही हमारे पास दो (शायद दस) चर एक्स और वाई हैं , और 50 के 50 के दो आयामी सरणी, हम इन चर को अपने सरणी के भीतर यादृच्छिक मान देते हैं, उदाहरण के लिए, एक्स = 26 , और वाई = 28। । उसके बाद, हम एक ही क्रिया को कई बार करते हैं: हमें शून्य से एक यादृच्छिक संख्या मिलती है

च र क ी स ं ख ् य ा * 2

$चर की संख्या * 2$

, हमारे मामले में, चार तक ; और फिर, बाहर गिराए गए संख्या के आधार पर, हम बदलते हैं
हमारे चर:

switch (Random.Range(0, 4)) { case 0: X += 1; break; case 1: X -= 1; break; case 2: Y += 1; break; case 3: Y -= 1; break; }

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

  X = X < 0 ? 0 : (X >= 50 ? 49 : X); Y = Y < 0 ? 0 : (Y >= 50 ? 49 : Y);

इन सभी जांचों के बाद, हम अपने सरणी के लिए नए X और Y मानों में कुछ करते हैं (उदाहरण के लिए: तत्व में एक जोड़ें) ।

 array[X, Y] += 1;

ट्रेनिंग

हमारे तरीकों के कार्यान्वयन और दृश्य की सादगी के लिए, क्या हम परिणामस्वरूप वस्तुओं को आकर्षित करेंगे? मुझे खुशी है कि आप बुरा नहीं मानते हैं! हम इसे Texture2D के साथ करेंगे।

काम करने के लिए, हमें केवल दो स्क्रिप्ट चाहिए:

ground_libray वह है जो लेख के चारों ओर घूमेगा । यहाँ हम उत्पन्न करते हैं, और स्वच्छ, और आकर्षित करते हैं

ग्राउंड_जेनरेटर वह है जो हमारे ग्राउंड_लिब्राय का उपयोग करेगा

पहले वाले को स्थिर होने दें और किसी चीज़ से विरासत में नहीं मिलेगा:

 public static class ground_libray

और दूसरा सामान्य है, केवल हमें अपडेट विधि की आवश्यकता नहीं होगी।

इसके अलावा, SpriteRenderer घटक के साथ, मंच पर एक गेम ऑब्जेक्ट बनाएं

व्यावहारिक भाग

इसमें क्या शामिल है?

डेटा के साथ काम करने के लिए, हम दो-आयामी सरणी का उपयोग करेंगे। आप बाइट या इंट से लेकर कलर तक , विभिन्न प्रकारों की एक सरणी ले सकते हैं, लेकिन मेरा मानना है कि यह सबसे अच्छा होगा:

नया प्रकार

इस बात को हम ग्राउंड_लिब्राय में लिखते हैं ।

 [System.Serializable] public class block { public float[] color = new float[3]; public block(Color col) { color = new float[3] { col.r, col.g, col.b }; } }

मैं इसे इस तथ्य से समझाऊंगा कि यह हमें अपने सरणी को बचाने और यदि आवश्यक हो तो इसे संशोधित करने की अनुमति देगा।

पुंजक

आइए, इससे पहले कि हम पहाड़ उत्पन्न करना शुरू करें, उस स्थान को नामित करें जहां हम इसे संग्रहीत करेंगे ।

ग्राउंड_गेंसर स्क्रिप्ट में , मैंने यह लिखा:

  public int ground_size = 128; ground_libray.block[,] ground; Texture2D myT;

ग्राउंड_साइज़ - हमारे क्षेत्र का आकार (यानी, सरणी में 16384 तत्व शामिल होंगे)।
ground_libray.block [,] ग्राउंड - यह पीढ़ी के लिए हमारा क्षेत्र है।
Texture2D myT वह है जिस पर हम आकर्षित होंगे।

कैसे चलेगा?

हमारे साथ काम करने का सिद्धांत इस प्रकार होगा - हम ग्राउंड_गेंनेटर से कुछ ग्राउंड_लिबरे विधियों को कहेंगे , जो हमारे पहले ग्राउंड फील्ड को दे रहे हैं।

चलिए ग्राउंड_लिबरे स्क्रिप्ट में पहला तरीका बनाते हैं:

पहाड़ बनाना

  public static float mount_noise = 0.02f; public static void generate_mount(ref block[,] b) { int h_now = b.GetLength(1) / 2; for (int x = 0; x < b.GetLength(0); x++) for (int y = 0; y < h_now; y++) { b[x, y] = new block(new Color(0.7f, 0.4f, 0)); h_now += Random.value > (1.0f - mount_noise) ? (Random.value > 0.5 ? 1 : -1) : 0; } }

और तुरंत ही हम यह समझने की कोशिश करेंगे कि यहाँ क्या हो रहा है: जैसा कि मैंने कहा, हम अभी अपने सरणी b के स्तंभों पर जाते हैं, उसी समय ऊँचाई चर h_now को बदलते हैं, जो मूल रूप से आधे 128 (64) के बराबर था। लेकिन अभी भी कुछ नया है - आरोह_नहीं । यह चर h_now बदलने की संभावना के लिए ज़िम्मेदार है, क्योंकि यदि आप ऊँचाई को बहुत बार बदलते हैं, तो पहाड़ एक कंघी की तरह दिखेगा।

रंग

मैंने तुरंत थोड़ा भूरा रंग सेट किया, इसे कम से कम कुछ होने दें - भविष्य में हमें इसकी आवश्यकता नहीं होगी।

अब चलिए ground_generator पर जाएँ और इसे Start विधि में लिखें:

  ground = new ground_libray.block [ground_size, ground_size]; ground_libray.generate_mount(ref ground);

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

मैं अपना पहाड़ क्यों नहीं देख सकता?

चलो अब हम क्या मिला!

ड्राइंग के लिए, हम अपने ग्राउंड_लिब्राय में निम्नलिखित विधि लिखेंगे :

ड्राइंग

  public static void paint(block[,] b, ref Texture2D t) { t = new Texture2D(b.GetLength(0), b.GetLength(1)); t.filterMode = FilterMode.Point; for (int x = 0; x < b.GetLength(0); x++) for (int y = 0; y < b.GetLength(1); y++) { if (b[x, y] == null) { t.SetPixel(x, y, new Color(0, 0, 0, 0)); continue; } t.SetPixel(x, y, new Color( b[x, y].color[0], b[x, y].color[1], b[x, y].color[2] ) ); } t.Apply(); }

यहां हम अब किसी को अपना क्षेत्र नहीं देंगे, हम केवल इसकी एक प्रति देंगे (हालांकि, शब्द वर्ग के कारण, हमने केवल एक प्रति से थोड़ा अधिक दिया) । हम इस विधि को अपना Texture2D भी देंगे।

पहली दो पंक्तियाँ: हम अपनी बनावट क्षेत्र के आकार को बनाते हैं और फ़िल्टरिंग को हटाते हैं ।

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

और, निश्चित रूप से, जब किया जाता है, हम ground_generator पर जाते हैं और इसे जोड़ते हैं:

  ground = new ground_libray.block [ground_size, ground_size]; ground_libray.generate_mount(ref ground); //   ground_libray.paint(ground, ref myT); GetComponent<SpriteRenderer>().sprite = Sprite.Create(myT, new Rect(0, 0, ground_size, ground_size), Vector3.zero );

लेकिन कोई फर्क नहीं पड़ता कि हम अपनी बनावट पर कितना आकर्षित करते हैं, खेल में हम केवल इस कैनवास को किसी चीज़ पर रखकर देख सकते हैं:

SpriteRenderer Texture2D को कहीं भी स्वीकार नहीं करता है, लेकिन कुछ भी हमें इस बनावट से स्प्राइट बनाने से रोकता है - Sprite.Create ( बनावट , निचले बाएं कोने के निर्देशांक और ऊपरी दाएं , अक्ष का समन्वय )।

इन पंक्तियों को नवीनतम कहा जाएगा, हम बाकी को पेंट विधि के ऊपर जोड़ देंगे!

मेरा

अब हमें अपने खेतों को यादृच्छिक गुफाओं से भरना होगा। इस तरह के कार्यों के लिए, हम ground_libray में एक अलग विधि भी बनाएंगे। मैं तुरंत विधि के मापदंडों की व्याख्या करना चाहूंगा:

 ref block[,] b -     . int thick -    int size -         Color outLine -

गुफा

  public static void make_cave(ref block[,] b, int thick, int size, Color outLine) { int xNow = Random.Range(0, b.GetLength(0)); int yNow = Random.Range(0, b.GetLength(1) / 2); for (int i = 0; i < size; i++) { b[xNow, yNow] = null; make_thick(ref b, thick, new int[2] { xNow, yNow }, outLine); switch (Random.Range(0, 4)) { case 0: xNow += 1; break; case 1: xNow -= 1; break; case 2: yNow += 1; break; case 3: yNow -= 1; break; } xNow = xNow < 0 ? 0 : (xNow >= b.GetLength(0) ? b.GetLength(0) - 1 : xNow); yNow = yNow < 0 ? 0 : (yNow >= b.GetLength(1) ? b.GetLength(1) - 1 : yNow); } }

शुरू करने के लिए, हमने अपने चर X और Y घोषित किए, लेकिन मैंने उन्हें क्रमशः xNow और yNow कहा।

पहला, अर्थात् xNow , पहले आयाम में शून्य से क्षेत्र के आकार तक एक यादृच्छिक मान प्राप्त करता है।

और दूसरा - yNow - भी एक यादृच्छिक मान प्राप्त करता है: शून्य से दूसरे आयाम में क्षेत्र के मध्य तक। क्यों? हम अपने पहाड़ को बीच से उत्पन्न करते हैं, मौका है कि यह "छत" तक बढ़ेगा महान नहीं है । इसके आधार पर, मैं हवा में गुफाएं बनाना प्रासंगिक नहीं मानता।

उसके बाद, एक लूप तुरंत जाता है, जिसमें से टिक की संख्या आकार पैरामीटर पर निर्भर करती है। प्रत्येक टिक हम xNow और yNow पदों पर फ़ील्ड को अपडेट करते हैं, और उसके बाद ही हम उन्हें स्वयं अपडेट करते हैं (फ़ील्ड अपडेट को अंत में रखा जा सकता है - आपको अंतर महसूस नहीं होगा)

एक मेक_थिक विधि भी है, जिसके मापदंडों में हम अपने क्षेत्र को पास करते हैं , गुफा स्ट्रोक की चौड़ाई, गुफा की वर्तमान अद्यतन स्थिति और स्ट्रोक का रंग :

स्ट्रोक

  static void make_thick (ref block[,] b, int t, int[] start, Color o) { for (int x = (start[0] - t); x < (start[0] + t); x++) { if (x < 0 || x >= b.GetLength(0)) continue; for (int y = (start[1] - t); y < (start[1] + t); y++) { if (y < 0 || y >= b.GetLength(1)) continue; if (b[x, y] == null) continue; b[x, y] = new block(o); } } }

विधि इसे करने के लिए पारित शुरू समन्वय लेता है, और चारों ओर एक दूरी पर टी रंग ओ में सभी ब्लॉकों repaints - सब कुछ बहुत सरल है!

अब इस लाइन को हमारे ग्राउंड_गेटर से जोड़ते हैं :

 ground_libray.make_cave(ref ground, 2, 10000, new Color(0.3f, 0.3f, 0.3f));

आप हमारे ऑब्जेक्ट पर एक घटक के रूप में ground_generator स्क्रिप्ट स्थापित कर सकते हैं और जांचें कि यह कैसे काम करता है!

गुफाओं के बारे में ...

अधिक गुफाएँ बनाने के लिए, आप मेक_कवे विधि को कई बार कॉल कर सकते हैं (एक लूप का उपयोग करें)
आकार के पैरामीटर को बदलने से हमेशा गुफा का आकार नहीं बढ़ता है, लेकिन अक्सर यह बड़ा हो जाता है
मोटे पैरामीटर को बदलकर, आप संचालन की संख्या में काफी वृद्धि करते हैं:
यदि पैरामीटर 3 है, तो 3 के त्रिज्या में वर्गों की संख्या 36 होगी, इसलिए पैरामीटर आकार = 40,000 के साथ , संचालन की संख्या 36 * 40,000 = 1440000 होगी

गुफा सुधार

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

कुछ # 4d4d4d के समावेशन से छुटकारा पाने के लिए हम इस विधि को ground_libray में लिखेंगे :

क्लीनर

  public static void clear_caves(ref block[,] b) { for (int x = 0; x < b.GetLength(0); x++) for (int y = 0; y < b.GetLength(1); y++) { if (b[x, y] == null) continue; if (solo(b, 2, 13, new int[2] { x, y })) b[x, y] = null; } }

लेकिन यह समझना मुश्किल होगा कि यहां क्या हो रहा है यदि आप नहीं जानते कि एकल फ़ंक्शन क्या करता है:

  static bool solo (block[,] b, int rad, int min, int[] start) { int cnt = 0; for (int x = (start[0] - rad); x <= (start[0] + rad); x++) { if (x < 0 || x >= b.GetLength(0)) continue; for (int y = (start[1] - rad); y <= (start[1] + rad); y++) { if (y < 0 || y >= b.GetLength(1)) continue; if (b[x, y] == null) cnt += 1; else continue; if (cnt >= min) return true; } } return false; }

इस फ़ंक्शन के मापदंडों में, हमारे क्षेत्र , बिंदु सत्यापन की त्रिज्या , "विनाश सीमा" और बिंदु के निर्देशांक की जाँच की जानी चाहिए।
यहाँ इस कार्य का विस्तृत विवरण दिया गया है:

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

मैंने 13 खाली बिंदुओं के लिए विनाश सीमा निर्धारित की है, और सत्यापन त्रिज्या 2 है (अर्थात, यह 24 बिंदुओं की जांच करेगा, केंद्रीय एक सहित नहीं)

उदाहरण

यह केवल 9 खाली बिंदु हैं, क्योंकि यह अप्रकाशित रहेगा।

लेकिन यह एक भाग्यशाली नहीं था - लगभग 14 खाली बिंदुओं के रूप में

एल्गोरिथ्म का एक संक्षिप्त विवरण: हम पूरे क्षेत्र से गुजरते हैं और सभी बिंदुओं की जांच करके देखते हैं कि क्या वे आवश्यक हैं।

इसके बाद, हम केवल हमारे ग्राउंड_गेंनेटर में निम्न पंक्ति जोड़ते हैं:

 ground_libray.clear_caves(ref ground);

परिणाम

जैसा कि हम देख सकते हैं, अधिकांश अनावश्यक कण बस चले गए।

कुछ रंग जोड़ें

हमारा पहाड़ बहुत नीरस दिखता है, मुझे यह उबाऊ लगता है।

चलो कुछ रंग जोड़ते हैं। Level_paint पद्धति को ग्राउंड_लिब्राय में जोड़ें:

पहाड़ों पर चित्रकारी

  public static void level_paint(ref block[,] b, Color[] all_c) { for (int x = 0; x < b.GetLength(0); x++) { int lvl_div = -1; int counter = 0; int lvl_now = 0; for (int y = b.GetLength(1) - 1; y > 0; y--) { if (b[x, y] != null && lvl_div == -1) lvl_div = y / all_c.Length; else if (b[x, y] == null) continue; b[x, y] = new block(all_c[lvl_now]); lvl_now += counter >= lvl_div ? 1 : 0; lvl_now = (lvl_now >= all_c.Length) ? (all_c.Length - 1) : lvl_now; counter = counter >= lvl_div ? 0 : (counter += 1); } } } </ <cut />source>           .    ,       ,   .       ,      .          <b>Y </b>  ,      . </spoiler>     <b>ground_generator </b> : <source lang="cs"> ground_libray.level_paint(ref ground, new Color[3] { new Color(0.2f, 0.8f, 0), new Color(0.6f, 0.2f, 0.05f), new Color(0.2f, 0.2f, 0.2f), });

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

परिणाम

लेकिन फिर भी रंगों में थोड़ा सा बेतरतीब जोड़ने के लिए यह बहुत सख्त है, हम इस संपत्ति को ground_libray में लिखेंगे :

यादृच्छिक रंग

  public static float color_randomize = 0.1f; static float crnd { get { return Random.Range(1.0f - color_randomize, 1.0f + color_randomize); } }

और अब level_paint और make_thick मेथड में, लाइनों में जहाँ हम रंग असाइन करते हैं, उदाहरण के लिए make_thick में :

 b[x, y] = new block(o);

हम इसे लिखेंगे:

 b[x, y] = new block(o * crnd);

और level_paint में

 b[x, y] = new block(all_c[lvl_now] * crnd);

अंत में, सब कुछ इस तरह दिखना चाहिए:

परिणाम

कमियों

मान लें कि हमारे पास 1024 से 1024 का एक क्षेत्र है, हमें 24 गुफाएं बनाने की आवश्यकता है, जिनमें से किनारों की मोटाई 4 होगी, और आकार 80,000 है।

1024 * 1024 + 24 * 64 * 80,000 = 5,368,832,000,000 ऑपरेशन।

यह विधि केवल खेल की दुनिया के लिए छोटे मॉड्यूल उत्पन्न करने के लिए उपयुक्त है , एक बार में कुछ बहुत बड़ा उत्पन्न करना असंभव है ।

यादृच्छिक दो-आयामी गुफा जनरेटर

प्रस्तावना

सिद्धांत

पहाड़

गुफा

ट्रेनिंग

व्यावहारिक भाग

इसमें क्या शामिल है?

पुंजक

मैं अपना पहाड़ क्यों नहीं देख सकता?

मेरा

गुफा सुधार

कुछ रंग जोड़ें

कमियों

More articles: