प्रक्रियात्मक पीढ़ी का उपयोग खेलों की परिवर्तनशीलता को बढ़ाने के लिए किया जाता है। जानी-मानी परियोजनाओं में Minecraft , Enter the Gungeon, और Descenders शामिल हैं। इस पोस्ट में, मैं उन कुछ एल्गोरिदम की व्याख्या करूँगा , जिनका उपयोग तिलमप प्रणाली के साथ काम करते समय किया जा सकता है, जो कि यूनिटी 2017.2 में 2 डी फ़ंक्शन के रूप में और रूलटाइल के साथ दिखाई दिया ।

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

यह पोस्ट किस बारे में है?

हम प्रक्रियात्मक दुनिया बनाने के सबसे सामान्य तरीकों में से कुछ पर गौर करेंगे, साथ ही मैंने कुछ बदलाव भी किए हैं। यहाँ एक उदाहरण है कि आप लेख पढ़ने के बाद क्या बना सकते हैं। तीन एल्गोरिदम एक साथ काम करने के लिए एक मानचित्र बनाने के लिए तिलमैप और नियम :


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

आगे पढ़ने से पहले, निम्नलिखित जानना अच्छा होगा:

1. हम भेद करते हैं कि एक टाइल क्या है और बाइनरी मान का उपयोग नहीं कर रहा है। 1 एक टाइल है, 0 इसकी अनुपस्थिति है।
2. हम प्रत्येक फ़ंक्शन के अंत में उपयोगकर्ता को लौटाए गए दो-आयामी पूर्णांक सरणी में सभी कार्डों को संग्रहीत करेंगे (उस स्थान को छोड़कर जहां प्रतिपादन किया जाता है)।
3. मैं प्रत्येक मानचित्र की ऊंचाई और चौड़ाई प्राप्त करने के लिए गेटअपबाउंड () सरणी फ़ंक्शन का उपयोग करूंगा , ताकि फ़ंक्शन को कम चर मिलें और कोड क्लीनर हो।
4. मैं अक्सर Mathf.FloorToInt () का उपयोग करता हूं क्योंकि टिलेमैप समन्वय प्रणाली नीचे बाईं ओर शुरू होती है और Mathf.FloorToInt () आपको पूर्णांक में संख्याओं को गोल करने की अनुमति देता है।
5. इस पोस्ट के सभी कोड C # में लिखे गए हैं।

अर्रे पीढ़ी

GenerateArray दिए गए आकार का एक नया int सरणी बनाता है। हम यह भी इंगित कर सकते हैं कि क्या सरणी को भरा जाना चाहिए या खाली (1 या 0) होना चाहिए। यहाँ कोड है:

 public static int[,] GenerateArray(int width, int height, bool empty) { int[,] map = new int[width, height]; for (int x = 0; x < map.GetUpperBound(0); x++) { for (int y = 0; y < map.GetUpperBound(1); y++) { if (empty) { map[x, y] = 0; } else { map[x, y] = 1; } } } return map; } 

नक्शा प्रस्तुत करना

इस फ़ंक्शन का उपयोग टाइल के नक्शे पर मानचित्र प्रस्तुत करने के लिए किया जाता है। हम नक्शे की चौड़ाई और ऊंचाई के चारों ओर लूप करते हैं, केवल टाइलें लगाते हैं जब परीक्षण बिंदु पर सरणी का मान 1 होता है।

 public static void RenderMap(int[,] map, Tilemap tilemap, TileBase tile) { //Clear the map (ensures we dont overlap) tilemap.ClearAllTiles(); //Loop through the width of the map for (int x = 0; x < map.GetUpperBound(0) ; x++) { //Loop through the height of the map for (int y = 0; y < map.GetUpperBound(1); y++) { // 1 = tile, 0 = no tile if (map[x, y] == 1) { tilemap.SetTile(new Vector3Int(x, y, 0), tile); } } } } 

नक्शा अद्यतन

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

 public static void UpdateMap(int[,] map, Tilemap tilemap) //Takes in our map and tilemap, setting null tiles where needed { for (int x = 0; x < map.GetUpperBound(0); x++) { for (int y = 0; y < map.GetUpperBound(1); y++) { //We are only going to update the map, rather than rendering again //This is because it uses less resources to update tiles to null //As opposed to re-drawing every single tile (and collision data) if (map[x, y] == 0) { tilemap.SetTile(new Vector3Int(x, y, 0), null); } } } } 

शोरगुल

पेर्लिन शोर का उपयोग विभिन्न उद्देश्यों के लिए किया जा सकता है। सबसे पहले, हम इसे अपने मानचित्र की शीर्ष परत बनाने के लिए उपयोग कर सकते हैं। ऐसा करने के लिए, बस वर्तमान स्थिति x और बीज का उपयोग करके एक नया बिंदु प्राप्त करें।

सरल उपाय

यह पीढ़ी पद्धति स्तरों की पीढ़ी में पेर्लिन शोर की प्राप्ति के सरलतम रूप का उपयोग करती है। हम Perlin के शोर के लिए एकता फ़ंक्शन ले सकते हैं ताकि हम स्वयं कोड न लिखें। हम Mathf.FloorToInt () फ़ंक्शन का उपयोग करके टाइल के नक्शे के लिए केवल पूर्णांक का भी उपयोग करेंगे।

 public static int[,] PerlinNoise(int[,] map, float seed) { int newPoint; //Used to reduced the position of the Perlin point float reduction = 0.5f; //Create the Perlin for (int x = 0; x < map.GetUpperBound(0); x++) { newPoint = Mathf.FloorToInt((Mathf.PerlinNoise(x, seed) - reduction) * map.GetUpperBound(1)); //Make sure the noise starts near the halfway point of the height newPoint += (map.GetUpperBound(1) / 2); for (int y = newPoint; y >= 0; y--) { map[x, y] = 1; } } return map; } 

टाइल के नक्शे को प्रस्तुत करने के बाद यह कैसा दिखता है:

चौरसाई

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

 public static int[,] PerlinNoiseSmooth(int[,] map, float seed, int interval) { //Smooth the noise and store it in the int array if (interval > 1) { int newPoint, points; //Used to reduced the position of the Perlin point float reduction = 0.5f; //Used in the smoothing process Vector2Int currentPos, lastPos; //The corresponding points of the smoothing. One list for x and one for y List<int> noiseX = new List<int>(); List<int> noiseY = new List<int>(); //Generate the noise for (int x = 0; x < map.GetUpperBound(0); x += interval) { newPoint = Mathf.FloorToInt((Mathf.PerlinNoise(x, (seed * reduction))) * map.GetUpperBound(1)); noiseY.Add(newPoint); noiseX.Add(x); } points = noiseY.Count; 

इस फ़ंक्शन के पहले भाग में, हम पहले जांचते हैं कि अंतराल एक से अधिक है या नहीं। यदि ऐसा है, तो शोर उत्पन्न करें। पीढ़ी अंतराल पर किया जाता है ताकि चौरसाई को लागू किया जा सके। फ़ंक्शन का अगला भाग बिंदुओं को सुचारू करना है।

 //Start at 1 so we have a previous position already for (int i = 1; i < points; i++) { //Get the current position currentPos = new Vector2Int(noiseX[i], noiseY[i]); //Also get the last position lastPos = new Vector2Int(noiseX[i - 1], noiseY[i - 1]); //Find the difference between the two Vector2 diff = currentPos - lastPos; //Set up what the height change value will be float heightChange = diff.y / interval; //Determine the current height float currHeight = lastPos.y; //Work our way through from the last x to the current x for (int x = lastPos.x; x < currentPos.x; x++) { for (int y = Mathf.FloorToInt(currHeight); y > 0; y--) { map[x, y] = 1; } currHeight += heightChange; } } } 

चौरसाई इस प्रकार की जाती है:

1. हमें वर्तमान और अंतिम स्थिति मिलती है
2. हम दो बिंदुओं के बीच अंतर प्राप्त करते हैं, सबसे महत्वपूर्ण जानकारी जो हमें चाहिए वह है y अक्ष के साथ अंतर
3. फिर हम यह निर्धारित करते हैं कि बिंदु पर पहुंचने के लिए कितना परिवर्तन करना है, यह अंतराल चर द्वारा y में अंतर को विभाजित करके किया जाता है।
4. इसके बाद, हम स्थान निर्धारित करना शुरू करते हैं, जिससे सभी शून्य हो जाते हैं
5. जब हम y अक्ष पर 0 तक पहुंचते हैं, तो ऊंचाई को वर्तमान ऊंचाई में जोड़ दें और अगले x स्थिति के लिए प्रक्रिया को दोहराएं
6. अंतिम और वर्तमान स्थिति के बीच प्रत्येक स्थिति के साथ समाप्त होने पर, हम अगले बिंदु पर जाते हैं

यदि अंतराल एक से कम है, तो हम बस पिछले फ़ंक्शन का उपयोग करते हैं, जो हमारे लिए सभी काम करेगा।

  else { //Defaults to a normal Perlin gen map = PerlinNoise(map, seed); } return map; 

आइए रेंडर पर एक नज़र डालें:

बेतरतीब चलना

रैंडम वॉक टॉप

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

 public static int[,] RandomWalkTop(int[,] map, float seed) { //Seed our random System.Random rand = new System.Random(seed.GetHashCode()); //Set our starting height int lastHeight = Random.Range(0, map.GetUpperBound(1)); //Cycle through our width for (int x = 0; x < map.GetUpperBound(0); x++) { //Flip a coin int nextMove = rand.Next(2); //If heads, and we aren't near the bottom, minus some height if (nextMove == 0 && lastHeight > 2) { lastHeight--; } //If tails, and we aren't near the top, add some height else if (nextMove == 1 && lastHeight < map.GetUpperBound(1) - 2) { lastHeight++; } //Circle through from the lastheight to the bottom for (int y = lastHeight; y >= 0; y--) { map[x, y] = 1; } } //Return the map return map; } 

एंटी-अलियासिंग के साथ रैंडम वॉक टॉप

ऐसी पीढ़ी हमें पेरलिन शोर पीढ़ी की तुलना में चिकनी ऊंचाइयां प्रदान करती है।

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

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

अब हम जानते हैं कि क्या जोड़ना है। आइए फ़ंक्शन पर एक नज़र डालें:

 public static int[,] RandomWalkTopSmoothed(int[,] map, float seed, int minSectionWidth) { //Seed our random System.Random rand = new System.Random(seed.GetHashCode()); //Determine the start position int lastHeight = Random.Range(0, map.GetUpperBound(1)); //Used to determine which direction to go int nextMove = 0; //Used to keep track of the current sections width int sectionWidth = 0; //Work through the array width for (int x = 0; x <= map.GetUpperBound(0); x++) { //Determine the next move nextMove = rand.Next(2); //Only change the height if we have used the current height more than the minimum required section width if (nextMove == 0 && lastHeight > 0 && sectionWidth > minSectionWidth) { lastHeight--; sectionWidth = 0; } else if (nextMove == 1 && lastHeight < map.GetUpperBound(1) && sectionWidth > minSectionWidth) { lastHeight++; sectionWidth = 0; } //Increment the section width sectionWidth++; //Work our way from the height down to 0 for (int y = lastHeight; y >= 0; y--) { map[x, y] = 1; } } //Return the modified map return map; } 

जैसा कि आप नीचे दिखाए गए gif में देख सकते हैं, यादृच्छिक चलना एल्गोरिथ्म को चौरसाई करने से आप स्तर पर सुंदर फ्लैट खंड प्राप्त कर सकते हैं।

निष्कर्ष

मुझे उम्मीद है कि यह लेख आपको अपनी परियोजनाओं में प्रक्रियात्मक पीढ़ी का उपयोग करने के लिए प्रेरित करता है। यदि आप प्रक्रियात्मक रूप से उत्पन्न नक्शों के बारे में अधिक जानना चाहते हैं, तो प्रक्रियात्मक पीढ़ी विकी या Roguebitant.com के उत्कृष्ट संसाधनों का पता लगाएं ।

लेख के दूसरे भाग में, हम गुफा प्रणाली बनाने के लिए प्रक्रियात्मक पीढ़ी का उपयोग करेंगे।

भाग २

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

शोरगुल

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

 public static int[,] PerlinNoiseCave(int[,] map, float modifier, bool edgesAreWalls) { int newPoint; for (int x = 0; x < map.GetUpperBound(0); x++) { for (int y = 0; y < map.GetUpperBound(1); y++) { if (edgesAreWalls && (x == 0 || y == 0 || x == map.GetUpperBound(0) - 1 || y == map.GetUpperBound(1) - 1)) { map[x, y] = 1; //Keep the edges as walls } else { //Generate a new point using Perlin noise, then round it to a value of either 0 or 1 newPoint = Mathf.RoundToInt(Mathf.PerlinNoise(x * modifier, y * modifier)); map[x, y] = newPoint; } } } return map; } 

हम बीज के बजाय संशोधक का उपयोग करते हैं क्योंकि 0 से 0.5 की संख्या से गुणा करने पर पेरलिन की पीढ़ी के परिणाम बेहतर दिखते हैं। मूल्य जितना कम होगा, परिणाम उतना अधिक अवरुद्ध होगा। नमूना परिणामों पर एक नज़र डालें। Gif 0.01 के संशोधक मूल्य से शुरू होता है और वृद्धिशील 0.25 के मान तक पहुंचता है।


इस gif से यह देखा जा सकता है कि प्रत्येक वृद्धि के साथ Perlin पीढ़ी केवल पैटर्न को बढ़ाती है।

बेतरतीब चलना

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

 public static int[,] RandomWalkCave(int[,] map, float seed, int requiredFloorPercent) { //Seed our random System.Random rand = new System.Random(seed.GetHashCode()); //Define our start x position int floorX = rand.Next(1, map.GetUpperBound(0) - 1); //Define our start y position int floorY = rand.Next(1, map.GetUpperBound(1) - 1); //Determine our required floorAmount int reqFloorAmount = ((map.GetUpperBound(1) * map.GetUpperBound(0)) * requiredFloorPercent) / 100; //Used for our while loop, when this reaches our reqFloorAmount we will stop tunneling int floorCount = 0; //Set our start position to not be a tile (0 = no tile, 1 = tile) map[floorX, floorY] = 0; //Increase our floor count floorCount++; 

फ़ंक्शन निम्न से शुरू होता है:

1. शुरुआती स्थिति का पता लगाएं
2. हटाए जाने वाले फर्श टाइल्स की संख्या की गणना करें।
3. प्रारंभिक स्थिति में टाइल को हटा दें
4. टाइल्स की संख्या में एक जोड़ें।

फिर हम while । वह एक गुफा बनाएगा:

 while (floorCount < reqFloorAmount) { //Determine our next direction int randDir = rand.Next(4); switch (randDir) { //Up case 0: //Ensure that the edges are still tiles if ((floorY + 1) < map.GetUpperBound(1) - 1) { //Move the y up one floorY++; //Check if that piece is currently still a tile if (map[floorX, floorY] == 1) { //Change it to not a tile map[floorX, floorY] = 0; //Increase floor count floorCount++; } } break; //Down case 1: //Ensure that the edges are still tiles if ((floorY - 1) > 1) { //Move the y down one floorY--; //Check if that piece is currently still a tile if (map[floorX, floorY] == 1) { //Change it to not a tile map[floorX, floorY] = 0; //Increase the floor count floorCount++; } } break; //Right case 2: //Ensure that the edges are still tiles if ((floorX + 1) < map.GetUpperBound(0) - 1) { //Move the x to the right floorX++; //Check if that piece is currently still a tile if (map[floorX, floorY] == 1) { //Change it to not a tile map[floorX, floorY] = 0; //Increase the floor count floorCount++; } } break; //Left case 3: //Ensure that the edges are still tiles if ((floorX - 1) > 1) { //Move the x to the left floorX--; //Check if that piece is currently still a tile if (map[floorX, floorY] == 1) { //Change it to not a tile map[floorX, floorY] = 0; //Increase the floor count floorCount++; } } break; } } //Return the updated map return map; } 

हम यहां क्या कर रहे हैं?

खैर, सबसे पहले, एक यादृच्छिक संख्या की मदद से, हम चुनते हैं कि किस दिशा में जाना है। फिर हम switch case साथ नई दिशा की जांच करते हैं। इस कथन में, हम जाँचते हैं कि क्या स्थिति एक दीवार है। यदि नहीं, तो सरणी से टाइल के साथ तत्व को हटा दें। हम ऐसा तब तक करते रहते हैं जब तक हम वांछित मंजिल क्षेत्र तक नहीं पहुँच जाते। परिणाम नीचे दिखाया गया है:


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

दिशात्मक सुरंग

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

 public static int[,] DirectionalTunnel(int[,] map, int minPathWidth, int maxPathWidth, int maxPathChange, int roughness, int curvyness) { //This value goes from its minus counterpart to its positive value, in this case with a width value of 1, the width of the tunnel is 3 int tunnelWidth = 1; //Set the start X position to the center of the tunnel int x = map.GetUpperBound(0) / 2; //Set up our random with the seed System.Random rand = new System.Random(Time.time.GetHashCode()); //Create the first part of the tunnel for (int i = -tunnelWidth; i <= tunnelWidth; i++) { map[x + i, 0] = 0; } 

क्या चल रहा है?

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

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


अब बाकी के नक्शे में आते हैं।

  //Cycle through the array for (int y = 1; y < map.GetUpperBound(1); y++) { //Check if we can change the roughness if (rand.Next(0, 100) > roughness) { //Get the amount we will change for the width int widthChange = Random.Range(-maxPathWidth, maxPathWidth); //Add it to our tunnel width value tunnelWidth += widthChange; //Check to see we arent making the path too small if (tunnelWidth < minPathWidth) { tunnelWidth = minPathWidth; } //Check that the path width isnt over our maximum if (tunnelWidth > maxPathWidth) { tunnelWidth = maxPathWidth; } } //Check if we can change the curve if (rand.Next(0, 100) > curvyness) { //Get the amount we will change for the x position int xChange = Random.Range(-maxPathChange, maxPathChange); //Add it to our x value x += xChange; //Check we arent too close to the left side of the map if (x < maxPathWidth) { x = maxPathWidth; } //Check we arent too close to the right side of the map if (x > (map.GetUpperBound(0) - maxPathWidth)) { x = map.GetUpperBound(0) - maxPathWidth; } } //Work through the width of the tunnel for (int i = -tunnelWidth; i <= tunnelWidth; i++) { map[x + i, y] = 0; } } return map; } 

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

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

इस कार्यान्वयन के परिणाम इस तरह दिखते हैं:

सेलुलर ऑटोमेटा

सेल्यूलर ऑटोमेटा पड़ोसी कोशिकाओं का उपयोग यह निर्धारित करने के लिए करता है कि क्या वर्तमान सेल चालू है (1) या बंद (0)। पड़ोसी कोशिकाओं का निर्धारण करने का आधार कोशिकाओं के बेतरतीब ढंग से उत्पन्न ग्रिड के आधार पर बनाया गया है। हम C # Random.Next फ़ंक्शन का उपयोग करके इस स्रोत ग्रिड को उत्पन्न करेंगे।

चूंकि हमारे पास सेलुलर ऑटोमेटा के विभिन्न कार्यान्वयन हैं, इसलिए मैंने इस मूल ग्रिड को बनाने के लिए एक अलग फ़ंक्शन लिखा है। फ़ंक्शन इस तरह दिखता है:

 public static int[,] GenerateCellularAutomata(int width, int height, float seed, int fillPercent, bool edgesAreWalls) { //Seed our random number generator System.Random rand = new System.Random(seed.GetHashCode()); //Initialise the map int[,] map = new int[width, height]; for (int x = 0; x < map.GetUpperBound(0); x++) { for (int y = 0; y < map.GetUpperBound(1); y++) { //If we have the edges set to be walls, ensure the cell is set to on (1) if (edgesAreWalls && (x == 0 || x == map.GetUpperBound(0) - 1 || y == 0 || y == map.GetUpperBound(1) - 1)) { map[x, y] = 1; } else { //Randomly generate the grid map[x, y] = (rand.Next(0, 100) < fillPercent) ? 1 : 0; } } } return map; } 

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

मूर का पड़ोस

मूर पड़ोस का उपयोग सेलुलर ऑटोमेटा की प्रारंभिक पीढ़ी को सुचारू करने के लिए किया जाता है। मूर का पड़ोस इस तरह दिखता है:


निम्नलिखित नियम पड़ोस पर लागू होते हैं:

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

मूर का पड़ोस जाँच कार्य निम्नानुसार है:

 static int GetMooreSurroundingTiles(int[,] map, int x, int y, bool edgesAreWalls) { /* Moore Neighbourhood looks like this ('T' is our tile, 'N' is our neighbours) * * NNN * NTN * NNN * */ int tileCount = 0; for(int neighbourX = x - 1; neighbourX <= x + 1; neighbourX++) { for(int neighbourY = y - 1; neighbourY <= y + 1; neighbourY++) { if (neighbourX >= 0 && neighbourX < map.GetUpperBound(0) && neighbourY >= 0 && neighbourY < map.GetUpperBound(1)) { //We don't want to count the tile we are checking the surroundings of if(neighbourX != x || neighbourY != y) { tileCount += map[neighbourX, neighbourY]; } } } } return tileCount; } 

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

 public static int[,] SmoothMooreCellularAutomata(int[,] map, bool edgesAreWalls, int smoothCount) { for (int i = 0; i < smoothCount; i++) { for (int x = 0; x < map.GetUpperBound(0); x++) { for (int y = 0; y < map.GetUpperBound(1); y++) { int surroundingTiles = GetMooreSurroundingTiles(map, x, y, edgesAreWalls); if (edgesAreWalls && (x == 0 || x == (map.GetUpperBound(0) - 1) || y == 0 || y == (map.GetUpperBound(1) - 1))) { //Set the edge to be a wall if we have edgesAreWalls to be true map[x, y] = 1; } //The default moore rule requires more than 4 neighbours else if (surroundingTiles > 4) { map[x, y] = 1; } else if (surroundingTiles < 4) { map[x, y] = 0; } } } } //Return the modified map return map; } 

यहां यह नोट करना महत्वपूर्ण है कि फ़ंक्शन में एक लूप है जो कई बार निर्दिष्ट संख्या को चौरसाई करता है। इसके लिए धन्यवाद, एक अधिक सुंदर कार्ड प्राप्त किया जाता है।


हम इस एल्गोरिथ्म को हमेशा कमरे को जोड़कर संशोधित कर सकते हैं, उदाहरण के लिए, उनके बीच केवल दो ब्लॉक हैं।

वॉन न्यूमैन पड़ोस

वॉन न्यूमैन पड़ोस सेलुलर ऑटोमेटा को लागू करने का एक और लोकप्रिय तरीका है। ऐसी पीढ़ी के लिए, हम मूर पीढ़ी की तुलना में एक सरल पड़ोस का उपयोग करते हैं। पड़ोस इस तरह दिखता है:


निम्नलिखित नियम पड़ोस पर लागू होते हैं:

• हम तिरछे लोगों पर विचार नहीं करते हुए, टाइल के तत्काल पड़ोसियों की जांच करते हैं।
• यदि कोशिका सक्रिय है, तो एक मात्रा में जोड़ें।
• यदि सेल निष्क्रिय है, तो कुछ भी न करें।
• यदि सेल में 2 से अधिक पड़ोसी हैं, तो हम वर्तमान सेल को सक्रिय बनाते हैं।
• यदि सेल में 2 से कम पड़ोसी हैं, तो हम वर्तमान सेल को निष्क्रिय करते हैं।
• यदि वास्तव में 2 पड़ोसी हैं, तो वर्तमान सेल को न बदलें।

दूसरा परिणाम पहले के समान सिद्धांतों का उपयोग करता है, लेकिन पड़ोस के क्षेत्र का विस्तार करता है।

हम निम्नलिखित फ़ंक्शन के साथ पड़ोसियों की जांच करते हैं:

 static int GetVNSurroundingTiles(int[,] map, int x, int y, bool edgesAreWalls) { /* von Neumann Neighbourhood looks like this ('T' is our Tile, 'N' is our Neighbour) * * N * NTN * N * */ int tileCount = 0; //Keep the edges as walls if(edgesAreWalls && (x - 1 == 0 || x + 1 == map.GetUpperBound(0) || y - 1 == 0 || y + 1 == map.GetUpperBound(1))) { tileCount++; } //Ensure we aren't touching the left side of the map if(x - 1 > 0) { tileCount += map[x - 1, y]; } //Ensure we aren't touching the bottom of the map if(y - 1 > 0) { tileCount += map[x, y - 1]; } //Ensure we aren't touching the right side of the map if(x + 1 < map.GetUpperBound(0)) { tileCount += map[x + 1, y]; } //Ensure we aren't touching the top of the map if(y + 1 < map.GetUpperBound(1)) { tileCount += map[x, y + 1]; } return tileCount; } 

पड़ोसियों की संख्या प्राप्त करने के बाद, हम सरणी को सुचारू करने के लिए आगे बढ़ सकते हैं। पहले की तरह, हमें forइनपुट को पारित किए गए चौरसाई पुनरावृत्तियों की संख्या को पूरा करने के लिए एक लूप की आवश्यकता है ।

 public static int[,] SmoothVNCellularAutomata(int[,] map, bool edgesAreWalls, int smoothCount) { for (int i = 0; i < smoothCount; i++) { for (int x = 0; x < map.GetUpperBound(0); x++) { for (int y = 0; y < map.GetUpperBound(1); y++) { //Get the surrounding tiles int surroundingTiles = GetVNSurroundingTiles(map, x, y, edgesAreWalls); if (edgesAreWalls && (x == 0 || x == map.GetUpperBound(0) - 1 || y == 0 || y == map.GetUpperBound(1))) { //Keep our edges as walls map[x, y] = 1; } //von Neuemann Neighbourhood requires only 3 or more surrounding tiles to be changed to a tile else if (surroundingTiles > 2) { map[x, y] = 1; } else if (surroundingTiles < 2) { map[x, y] = 0; } } } } //Return the modified map return map; } 

जैसा कि आप नीचे देख सकते हैं, अंतिम परिणाम मूर के पड़ोस की तुलना में बहुत अधिक अवरुद्ध है:


यहाँ, मूर के आसपास के क्षेत्र में, आप नक्शे के हिस्सों के बीच कनेक्शन को अनुकूलित करने के लिए एक अतिरिक्त स्क्रिप्ट चला सकते हैं।

निष्कर्ष

मुझे उम्मीद है कि यह लेख आपको अपनी परियोजनाओं में किसी प्रकार की प्रक्रियात्मक पीढ़ी का उपयोग करने के लिए प्रेरित करता है। यदि आपने प्रोजेक्ट डाउनलोड नहीं किया है, तो आप इसे यहां प्राप्त कर सकते हैं ।