भाग 1-3: जाल, रंग और सेल ऊँचाई

भाग 4-7: धक्कों, नदियों और सड़कों

भाग 8-11: जल, भू-भाग और प्राचीर

भाग 12-15: बचत और लोडिंग, बनावट, दूरियां

भाग 16-19: रास्ता खोजना, खिलाड़ी दस्ते, एनिमेशन

भाग 20-23: कोहरे के युद्ध, मानचित्र अनुसंधान, प्रक्रियात्मक पीढ़ी

भाग 24-27: जल चक्र, अपरदन, बायोम, बेलनाकार नक्शा

भाग 24: क्षेत्र और क्षरण

मानचित्र के चारों ओर पानी की सीमा जोड़ें।
हम मानचित्र को कई क्षेत्रों में विभाजित करते हैं।
हम कटाव का उपयोग चट्टानों को काटने के लिए करते हैं।
हम राहत को सुचारू करने के लिए भूमि को आगे बढ़ाते हैं।

पिछले भाग में, हमने प्रक्रियात्मक मानचित्र निर्माण के लिए नींव रखी। इस बार हम भूमि की संभावित घटना के स्थानों को सीमित करेंगे और उस पर कटाव के साथ कार्य करेंगे।

यह ट्यूटोरियल एकता 2017.1.0 में बनाया गया था।

भूमि को अलग और चिकना करना।

नक्शा सीमा

चूंकि हम भूमि क्षेत्रों को अनियमित रूप से बढ़ाते हैं, इसलिए ऐसा हो सकता है कि भूमि मानचित्र के किनारे को छू ले। यह अवांछनीय हो सकता है। पानी-सीमित नक्शे में एक प्राकृतिक अवरोध होता है जो खिलाड़ियों को किनारे पर आने से रोकता है। इसलिए, यह अच्छा होगा कि हम भूमि को मानचित्र के किनारे के पास पानी के स्तर से ऊपर उठने से मना करें।

सीमा का आकार

मानचित्र के किनारे भूमि कितनी निकट होनी चाहिए? इस प्रश्न का कोई सही उत्तर नहीं है, इसलिए हम इस पैरामीटर को अनुकूलन योग्य बनाएंगे। हम HexMapGenerator घटक में दो स्लाइडर्स HexMapGenerator , एक एक्स अक्ष पर किनारों के साथ सीमाओं के लिए, दूसरा Z अक्ष के साथ सीमाओं के लिए। इसलिए हम आयामों में से एक में एक व्यापक सीमा का उपयोग कर सकते हैं, या केवल एक आयाम में एक सीमा बना सकते हैं। 5 के डिफ़ॉल्ट मान के साथ 0 से 10 के अंतराल का उपयोग करते हैं।

  [Range(0, 10)] public int mapBorderX = 5; [Range(0, 10)] public int mapBorderZ = 5;

नक्शा सीमाओं स्लाइडर्स।

हम भूमि क्षेत्रों के केंद्रों को सीमित करते हैं

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

  int xMin, xMax, zMin, zMax;

हम सुशी बनाने से पहले GenerateMap में बाधाओं को शुरू करते हैं। हम इन मूल्यों का उपयोग Random.Range कॉल के मापदंडों के रूप में करते हैं, इसलिए उच्च वास्तव में असाधारण हैं। सीमा के बिना, वे माप कोशिकाओं की संख्या के बराबर हैं, इसलिए, शून्य से 1 नहीं।

  public void GenerateMap (int x, int z) { … for (int i = 0; i < cellCount; i++) { grid.GetCell(i).WaterLevel = waterLevel; } xMin = mapBorderX; xMax = x - mapBorderX; zMin = mapBorderZ; zMax = z - mapBorderZ; CreateLand(); … }

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

  HexCell GetRandomCell () { // return grid.GetCell(Random.Range(0, cellCount)); return grid.GetCell(Random.Range(xMin, xMax), Random.Range(zMin, zMax)); }

मानचित्र की सीमाएँ 0 × 0, 5 × 5, 10 × 10 और 0 × 10 हैं।

जब सभी मानचित्र पैरामीटर उनके डिफ़ॉल्ट मानों पर सेट होते हैं, तो आकार 5 की सीमा मज़बूती से नक्शे के किनारे को स्पर्श करने वाली भूमि से बचाएगी। हालांकि, यह गारंटी नहीं है। भूमि कभी-कभी किनारे के करीब हो सकती है, और कभी-कभी इसे कई स्थानों पर छू सकती है।

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

आ र

$आर$ यह होता है

$3r ^ 2 + 3r + 1$ कोशिकाओं। यदि सीमा के आकार के बराबर त्रिज्या के साथ हेक्सागोन्स हैं, तो वे इसे पार कर सकते हैं। 5 की त्रिज्या के साथ एक पूर्ण षट्भुज में 91 कोशिकाएं होती हैं। चूंकि डिफ़ॉल्ट रूप से अधिकतम प्रति खंड 100 सेल है, इसका मतलब है कि भूमि 5 कोशिकाओं में एक पुल बिछाने में सक्षम होगी, खासकर अगर कंपन होते हैं। ऐसा होने से रोकने के लिए, या तो भूखंड के अधिकतम आकार को कम करें, या सीमा के आकार को बढ़ाएं।

व्युत्पन्न हेक्सागोनल क्षेत्र में कोशिकाओं की संख्या के लिए सूत्र कैसे है?

0 की त्रिज्या के साथ, हम एक एकल कोशिका के साथ काम कर रहे हैं। यह 1 से आया था। केंद्र के चारों ओर 1 की त्रिज्या के साथ, छह अतिरिक्त कोशिकाएं हैं, अर्थात्

$6 + 1$ । इन छह कोशिकाओं को केंद्र को छूने वाले छह त्रिकोणों के छोर माना जा सकता है। 2 की त्रिज्या के साथ, इन त्रिभुजों में एक दूसरी पंक्ति जोड़ी जाती है, अर्थात, त्रिकोण पर दो और कोशिकाएँ प्राप्त होती हैं, और कुल में

$6 (1 + 2) + 1$ । 3 के त्रिज्या के साथ, एक तीसरी पंक्ति जोड़ी जाती है, अर्थात्, प्रति त्रिकोण तीन और कोशिकाएं, और कुल में

$6 (1 + 2 + 3) + 1$ । और इसी तरह। अर्थात्, सामान्य शब्दों में, सूत्र जैसा दिखता है

$6 (sum_ (i = 1) ^ r i) +1 = 6 (((r + 1)) / 2) +1 = 3r (r + 1) + 1 = 3r ^ 2 + 3r + 1$ ।

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

भूमि के भूखंड का आकार 200 है, मानचित्र की सीमाएं 5 और 10 हैं।

पैंजिया

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

10 की सीमा के साथ 40% सुशी।

पैंजिया नाम कहां से आया?

यह अंतिम ज्ञात सुपरकॉन्टिनेंट का नाम था जो कई साल पहले पृथ्वी पर मौजूद था। यह नाम ग्रीक शब्दों पैन और गैया से बना है, जिसका अर्थ है "सभी प्रकृति" या "सभी भूमि"।

हम असंभव कार्ड से रक्षा करते हैं

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

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

एक बड़े मानचित्र के लिए, एक हजार पुनरावृत्तियों स्वीकार्य हैं, और दस हजार पुनरावृत्तियों पहले से ही बेतुके लगते हैं। तो चलिए इस मूल्य को समाप्ति बिंदु के रूप में उपयोग करते हैं।

  void CreateLand () { int landBudget = Mathf.RoundToInt(cellCount * landPercentage * 0.01f); // while (landBudget > 0) { for (int guard = 0; landBudget > 0 && guard < 10000; guard++) { int chunkSize = Random.Range(chunkSizeMin, chunkSizeMax - 1); … } }

यदि हमें एक क्षतिग्रस्त नक्शा मिलता है, तो 10,000 पुनरावृत्तियों में अधिक समय नहीं लगेगा, क्योंकि कई कोशिकाएं जल्दी से अधिकतम ऊंचाई तक पहुंच जाएंगी, जो नए क्षेत्रों को बढ़ने से रोकेंगी।

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

  void CreateLand () { … if (landBudget > 0) { Debug.LogWarning("Failed to use up " + landBudget + " land budget."); } }

10 की सीमा के साथ 95% भूमि पूरी राशि खर्च नहीं कर सकती थी।

एक विफल कार्ड में अभी भी भिन्नता क्यों है?

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

unitypackage

एक कार्ड का विभाजन

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

मानचित्र क्षेत्र

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

 // int xMin, xMax, zMin, zMax; struct MapRegion { public int xMin, xMax, zMin, zMax; } MapRegion region;

सब कुछ काम करने के लिए, हमें GenerateMap में न्यूनतम-अधिकतम फ़ील्ड में उपसर्ग जोड़ने की आवश्यकता है region. ।

  region.xMin = mapBorderX; region.xMax = x - mapBorderX; region.zMin = mapBorderZ; region.zMax = z - mapBorderZ;

और GetRandomCell में भी।

  HexCell GetRandomCell () { return grid.GetCell( Random.Range(region.xMin, region.xMax), Random.Range(region.zMin, region.zMax) ); }

कई क्षेत्रों

कई क्षेत्रों का समर्थन करने के लिए, क्षेत्रों की MapRegion सूची के MapRegion फ़ील्ड MapRegion बदलें।

 // MapRegion region; List<MapRegion> regions;

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

  void CreateRegions () { if (regions == null) { regions = new List<MapRegion>(); } else { regions.Clear(); } MapRegion region; region.xMin = mapBorderX; region.xMax = grid.cellCountX - mapBorderX; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); }

हम GenerateMap में इस विधि को कॉल करेंगे, और हम सीधे क्षेत्र नहीं बनाएंगे।

 // region.xMin = mapBorderX; // region.xMax = x - mapBorderX; // region.zMin = mapBorderZ; // region.zMax = z - mapBorderZ; CreateRegions(); CreateLand();

ताकि GetRandomCell एक मनमाना क्षेत्र के साथ काम कर GetRandomCell , इसे MapRegion पैरामीटर दे।

  HexCell GetRandomCell (MapRegion region) { return grid.GetCell( Random.Range(region.xMin, region.xMax), Random.Range(region.zMin, region.zMax) ); }

अब RaiseTerraion और SinkTerrain लिए इसी क्षेत्र को पारित करना चाहिए। ऐसा करने के लिए, उनमें से प्रत्येक को एक क्षेत्र पैरामीटर की भी आवश्यकता होती है।

  int RaiseTerrain (int chunkSize, int budget, MapRegion region) { searchFrontierPhase += 1; HexCell firstCell = GetRandomCell(region); … } int SinkTerrain (int chunkSize, int budget, MapRegion region) { searchFrontierPhase += 1; HexCell firstCell = GetRandomCell(region); … }

CreateLand विधि प्रत्येक क्षेत्र को अनुभागों को बढ़ाने या कम करने के लिए निर्धारित करनी चाहिए। क्षेत्रों के बीच की भूमि को संतुलित करने के लिए, हम बस चक्र में क्षेत्रों की सूची में बार-बार जाएंगे।

  void CreateLand () { int landBudget = Mathf.RoundToInt(cellCount * landPercentage * 0.01f); for (int guard = 0; landBudget > 0 && guard < 10000; guard++) { for (int i = 0; i < regions.Count; i++) { MapRegion region = regions[i]; int chunkSize = Random.Range(chunkSizeMin, chunkSizeMax - 1); if (Random.value < sinkProbability) { landBudget = SinkTerrain(chunkSize, landBudget, region); } else { landBudget = RaiseTerrain(chunkSize, landBudget, region); } } } if (landBudget > 0) { Debug.LogWarning("Failed to use up " + landBudget + " land budget."); } }

हालांकि, हमें अभी भी समान रूप से वितरित भूखंडों के निचले हिस्से को बनाने की आवश्यकता है। यह सभी क्षेत्रों के लिए निर्णय लेते समय किया जा सकता है कि क्या उन्हें छोड़ना है।

  for (int guard = 0; landBudget > 0 && guard < 10000; guard++) { bool sink = Random.value < sinkProbability; for (int i = 0; i < regions.Count; i++) { MapRegion region = regions[i]; int chunkSize = Random.Range(chunkSizeMin, chunkSizeMax - 1); // if (Random.value < sinkProbability) { if (sink) { landBudget = SinkTerrain(chunkSize, landBudget, region); } else { landBudget = RaiseTerrain(chunkSize, landBudget, region); } } }

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

 // for (int guard = 0; landBudget > 0 && guard < 10000; guard++) { for (int guard = 0; guard < 10000; guard++) { bool sink = Random.value < sinkProbability; for (int i = 0; i < regions.Count; i++) { MapRegion region = regions[i]; int chunkSize = Random.Range(chunkSizeMin, chunkSizeMax - 1); if (sink) { landBudget = SinkTerrain(chunkSize, landBudget, region); } else { landBudget = RaiseTerrain(chunkSize, landBudget, region); if (landBudget == 0) { return; } } } }

दो क्षेत्रों

हालाँकि अब हमारे पास कई क्षेत्रों का समर्थन है, फिर भी हम केवल एक ही पूछते हैं। चलिए CreateRegions को CreateRegions ताकि यह मैप को आधा वर्टिकल में विभाजित करे। ऐसा करने के लिए, हम जोड़ा क्षेत्र के xMax मान को आधा करते हैं। फिर हम xMin लिए समान मान का उपयोग करते हैं और फिर से xMin लिए मूल मान का उपयोग करते हैं, इसे दूसरे क्षेत्र के रूप में उपयोग करते हैं।

  MapRegion region; region.xMin = mapBorderX; region.xMax = grid.cellCountX / 2; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); region.xMin = grid.cellCountX / 2; region.xMax = grid.cellCountX - mapBorderX; regions.Add(region);

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

  [Range(0, 10)] public int regionBorder = 5;

क्षेत्र की सीमा स्लाइडर।

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

इस क्षेत्र की सीमा को लागू करने के लिए, इसे पहले क्षेत्र के xMax से xMax और दूसरे क्षेत्र को xMin ।

  MapRegion region; region.xMin = mapBorderX; region.xMax = grid.cellCountX / 2 - regionBorder; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); region.xMin = grid.cellCountX / 2 + regionBorder; region.xMax = grid.cellCountX - mapBorderX; regions.Add(region);

मानचित्र को लंबवत रूप से दो क्षेत्रों में विभाजित किया गया है।

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

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

  MapRegion region; if (Random.value < 0.5f) { region.xMin = mapBorderX; region.xMax = grid.cellCountX / 2 - regionBorder; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); region.xMin = grid.cellCountX / 2 + regionBorder; region.xMax = grid.cellCountX - mapBorderX; regions.Add(region); } else { region.xMin = mapBorderX; region.xMax = grid.cellCountX - mapBorderX; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ / 2 - regionBorder; regions.Add(region); region.zMin = grid.cellCountZ / 2 + regionBorder; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); }

मानचित्र क्षैतिज रूप से दो क्षेत्रों में विभाजित है।

चूंकि हम एक विस्तृत मानचित्र का उपयोग करते हैं, इसलिए क्षैतिज पृथक्करण के साथ व्यापक और पतले क्षेत्र बनाए जाएंगे। नतीजतन, इन क्षेत्रों में कई विभाजित भूमि जनता के गठन की संभावना है।

चार क्षेत्र

आइए क्षेत्रों की संख्या को अनुकूलन योग्य बनाएं, 1 से 4 क्षेत्रों का समर्थन बनाएं।

  [Range(1, 4)] public int regionCount = 1;

क्षेत्रों की संख्या के लिए स्लाइडर।

हम संबंधित क्षेत्र कोड के निष्पादन का चयन करने के लिए switch का उपयोग कर सकते हैं। हम एक क्षेत्र के कोड को दोहराते हुए शुरू करते हैं, जिसका उपयोग डिफ़ॉल्ट रूप से किया जाएगा, और केस 2 के लिए दो क्षेत्रों के कोड को छोड़ दें।

  MapRegion region; switch (regionCount) { default: region.xMin = mapBorderX; region.xMax = grid.cellCountX - mapBorderX; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); break; case 2: if (Random.value < 0.5f) { region.xMin = mapBorderX; region.xMax = grid.cellCountX / 2 - regionBorder; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); region.xMin = grid.cellCountX / 2 + regionBorder; region.xMax = grid.cellCountX - mapBorderX; regions.Add(region); } else { region.xMin = mapBorderX; region.xMax = grid.cellCountX - mapBorderX; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ / 2 - regionBorder; regions.Add(region); region.zMin = grid.cellCountZ / 2 + regionBorder; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); } break; }

स्विच स्टेटमेंट क्या है?

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

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

  switch (regionCount) { default: CreateOneRegion(); break; case 2: CreateTwoRegions(); break; case 3: CreateThreeRegions(); break; case 4: CreateFourRegions(); break; }

तीन क्षेत्र दो के समान हैं, केवल तिहाई का उपयोग आधे के बजाय किया जाता है। इस मामले में, क्षैतिज विभाजन बहुत संकीर्ण क्षेत्र बनाएगा, इसलिए हमने केवल ऊर्ध्वाधर विभाजन के लिए समर्थन बनाया। ध्यान दें कि परिणामस्वरूप हमने क्षेत्र के सीमा क्षेत्र को दोगुना कर दिया है, इसलिए नए क्षेत्रों को बनाने का स्थान दो क्षेत्रों की तुलना में कम है।

  switch (regionCount) { default: … break; case 2: … break; case 3: region.xMin = mapBorderX; region.xMax = grid.cellCountX / 3 - regionBorder; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); region.xMin = grid.cellCountX / 3 + regionBorder; region.xMax = grid.cellCountX * 2 / 3 - regionBorder; regions.Add(region); region.xMin = grid.cellCountX * 2 / 3 + regionBorder; region.xMax = grid.cellCountX - mapBorderX; regions.Add(region); break; }

तीन क्षेत्र।

क्षैतिज और ऊर्ध्वाधर पृथक्करण के संयोजन और मानचित्र के प्रत्येक कोने में एक क्षेत्र को जोड़कर चार क्षेत्र बनाए जा सकते हैं।

  switch (regionCount) { … case 4: region.xMin = mapBorderX; region.xMax = grid.cellCountX / 2 - regionBorder; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ / 2 - regionBorder; regions.Add(region); region.xMin = grid.cellCountX / 2 + regionBorder; region.xMax = grid.cellCountX - mapBorderX; regions.Add(region); region.zMin = grid.cellCountZ / 2 + regionBorder; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); region.xMin = mapBorderX; region.xMax = grid.cellCountX / 2 - regionBorder; regions.Add(region); break; } }

चार क्षेत्र।

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

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

unitypackage

कटाव

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

  public void GenerateMap (int x, int z) { … CreateRegions(); CreateLand(); ErodeLand(); SetTerrainType(); … } … void ErodeLand () {}

कटाव प्रतिशत

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

  [Range(0, 100)] public int erosionPercentage = 50;

कटाव स्लाइडर।

क्षरण नष्ट करने वाली कोशिकाओं की खोज करें

कटाव राहत को चिकना बनाता है। हमारे मामले में, एकमात्र तेज भाग चट्टान हैं। इसलिए, वे क्षरण प्रक्रिया का लक्ष्य होंगे। यदि एक चट्टान मौजूद है, तो क्षरण को तब तक कम करना चाहिए जब तक कि यह अंत में ढलान में बदल न जाए। हम ढलानों को चिकना नहीं करेंगे, क्योंकि यह एक उबाऊ इलाके को जन्म देगा। ऐसा करने के लिए, हमें यह निर्धारित करने की आवश्यकता है कि कौन सी कोशिकाएं चट्टानों के शीर्ष पर हैं, और उनकी ऊंचाई कम है। ये अपरदन-प्रवण कोशिकाएँ होंगी।

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

  bool IsErodible (HexCell cell) { int erodibleElevation = cell.Elevation - 2; for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = cell.GetNeighbor(d); if (neighbor && neighbor.Elevation <= erodibleElevation) { return true; } } return false; }

हम ErodeLandसभी कोशिकाओं के माध्यम से लूप में इस विधि का उपयोग कर सकते हैं और सभी इरोजन-प्रवण कोशिकाओं को एक अस्थायी सूची में लिख सकते हैं।

  void ErodeLand () { List<HexCell> erodibleCells = ListPool<HexCell>.Get(); for (int i = 0; i < cellCount; i++) { HexCell cell = grid.GetCell(i); if (IsErodible(cell)) { erodibleCells.Add(cell); } } ListPool<HexCell>.Add(erodibleCells); }

एक बार जब हम कटाव-प्रवण कोशिकाओं की कुल संख्या जानते हैं, तो हम शेष कटाव-प्रवण कोशिकाओं की संख्या निर्धारित करने के लिए कटाव के प्रतिशत का उपयोग कर सकते हैं। उदाहरण के लिए, यदि प्रतिशत 50 है, तो हमें कोशिकाओं का क्षरण तब तक होना चाहिए, जब तक कि मूल मात्रा आधी न रह जाए। यदि प्रतिशत 100 है, तो हम तब तक नहीं रुकेंगे जब तक हम सभी क्षरण-प्रवण कोशिकाओं को नष्ट नहीं कर देते।

  void ErodeLand () { List<HexCell> erodibleCells = ListPool<HexCell>.Get(); for (int i = 0; i < cellCount; i++) { … } int targetErodibleCount = (int)(erodibleCells.Count * (100 - erosionPercentage) * 0.01f); ListPool<HexCell>.Add(erodibleCells); }

क्या हमें केवल भूमि कटाव-प्रवण कोशिकाओं पर विचार नहीं करना चाहिए?

. , , .

कोशिका की कमी

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

  int targetErodibleCount = (int)(erodibleCells.Count * (100 - erosionPercentage) * 0.01f); while (erodibleCells.Count > targetErodibleCount) { int index = Random.Range(0, erodibleCells.Count); HexCell cell = erodibleCells[index]; cell.Elevation -= 1; erodibleCells.Remove(cell); } ListPool<HexCell>.Add(erodibleCells);

आवश्यक खोज को रोकने के लिए erodibleCells.Remove, हम सूची में वर्तमान सेल को फिर से लिखेंगे, और फिर अंतिम तत्व को हटा देंगे। हमें अब भी उनके आदेश की परवाह नहीं है।

 // erodibleCells.Remove(cell); erodibleCells[index] = erodibleCells[erodibleCells.Count - 1]; erodibleCells.RemoveAt(erodibleCells.Count - 1);

क्षरण-प्रवण कोशिकाओं के 0% और 100% की कमी, बीज मानचित्र 1957632474।

कटाव ट्रैकिंग

हमारा भोला दृष्टिकोण हमें क्षरण को लागू करने की अनुमति देता है, लेकिन सही डिग्री तक नहीं। ऐसा इसलिए होता है क्योंकि ऊंचाई में एक के बाद एक सेल अभी भी क्षरण का खतरा बना रह सकता है। इसलिए, हम सूची से एक सेल को केवल तभी हटाएंगे जब यह क्षरण के अधीन नहीं है।

  if (!IsErodible(cell)) { erodibleCells[index] = erodibleCells[erodibleCells.Count - 1]; erodibleCells.RemoveAt(erodibleCells.Count - 1); }

सूची में क्षरण-प्रवण कोशिकाओं को बनाए रखते हुए 100% क्षरण।

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

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

  if (!IsErodible(cell)) { erodibleCells[index] = erodibleCells[erodibleCells.Count - 1]; erodibleCells.RemoveAt(erodibleCells.Count - 1); } for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = cell.GetNeighbor(d); if ( neighbor && IsErodible(neighbor) && !erodibleCells.Contains(neighbor) ) { erodibleCells.Add(neighbor); } }

सभी नष्ट कोशिकाओं को छोड़ दिया जाता है।

हम बहुत जमीन बचाते हैं

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

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

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

  HexCell GetErosionTarget (HexCell cell) { List<HexCell> candidates = ListPool<HexCell>.Get(); int erodibleElevation = cell.Elevation - 2; for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = cell.GetNeighbor(d); if (neighbor && neighbor.Elevation <= erodibleElevation) { candidates.Add(neighbor); } } HexCell target = candidates[Random.Range(0, candidates.Count)]; ListPool<HexCell>.Add(candidates); return target; }

जैसा कि ErodeLandहम लक्ष्य सेल को परिभाषित करने के तुरंत बाद का चयन सेल घिस। फिर हम सेल हाइट्स को एक के बाद एक तुरंत घटाते और बढ़ाते हैं। इस मामले में, लक्ष्य सेल स्वयं कटाव के लिए अतिसंवेदनशील हो सकता है, लेकिन यह स्थिति तब हल हो जाती है जब हम नए नष्ट सेल के पड़ोसियों की जांच करते हैं।

  HexCell cell = erodibleCells[index]; HexCell targetCell = GetErosionTarget(cell); cell.Elevation -= 1; targetCell.Elevation += 1; if (!IsErodible(cell)) { erodibleCells[index] = erodibleCells[erodibleCells.Count - 1]; erodibleCells.RemoveAt(erodibleCells.Count - 1); }

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

  for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = cell.GetNeighbor(d); … } for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = targetCell.GetNeighbor(d); if ( neighbor && !IsErodible(neighbor) && erodibleCells.Contains(neighbor) ) { erodibleCells.Remove(neighbor); } }

भूमि द्रव्यमान को बनाए रखते हुए 100% क्षरण।

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

त्वरित कटाव

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

  for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = targetCell.GetNeighbor(d); if ( neighbor && neighbor != cell && !IsErodible(neighbor) && erodibleCells.Contains(neighbor) ) { erodibleCells.Remove(neighbor); } }

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

  HexCell neighbor = targetCell.GetNeighbor(d); if ( neighbor && neighbor != cell && neighbor.Elevation == targetCell.Elevation + 1 && !IsErodible(neighbor) // && erodibleCells.Contains(neighbor) ) { erodibleCells.Remove(neighbor); }

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

  HexCell neighbor = cell.GetNeighbor(d); if ( neighbor && neighbor.Elevation == cell.Elevation + 2 && // IsErodible(neighbor) && !erodibleCells.Contains(neighbor) ) { erodibleCells.Add(neighbor); }

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

  if (!IsErodible(cell)) { erodibleCells[index] = erodibleCells[erodibleCells.Count - 1]; erodibleCells.RemoveAt(erodibleCells.Count - 1); } for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { … } if (IsErodible(targetCell) && !erodibleCells.Contains(targetCell)) { erodibleCells.Add(targetCell); } for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { … }

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

25%, 50%, 75% और 100% क्षरण।

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

चार पूरी तरह से मिट क्षेत्र अभी भी अलग रहते हैं।

unitypackage

भाग 25: जल चक्र

कच्चे मानचित्र डेटा प्रदर्शित करें।
हम कोशिकाओं का एक वातावरण बनाते हैं।
पानी के चक्र का एक आंशिक सिमुलेशन बनाएं।

इस भाग में हम भूमि पर आर्द्रता जोड़ेंगे।

इस ट्यूटोरियल को एकता 2017.3.0 में बनाया गया था।

हम बायोम को निर्धारित करने के लिए पानी के चक्र का उपयोग करते हैं।

बादल

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

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

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

डेटा विज़ुअलाइज़ेशन

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

  Properties { _Color ("Color", Color) = (1,1,1,1) _MainTex ("Terrain Texture Array", 2DArray) = "white" {} _GridTex ("Grid Texture", 2D) = "white" {} _Glossiness ("Smoothness", Range(0,1)) = 0.5 _Specular ("Specular", Color) = (0.2, 0.2, 0.2) _BackgroundColor ("Background Color", Color) = (0,0,0) [Toggle(SHOW_MAP_DATA)] _ShowMapData ("Show Map Data", Float) = 0 }

मानचित्र डेटा प्रदर्शित करने के लिए स्विच करें।

कीवर्ड समर्थन को सक्षम करने के लिए एक shader फ़ंक्शन जोड़ें।

  #pragma multi_compile _ GRID_ON #pragma multi_compile _ HEX_MAP_EDIT_MODE #pragma shader_feature SHOW_MAP_DATA

हम इसे एक एकल फ्लोट प्रदर्शित करेंगे, जैसा कि बाकी राहत डेटा के साथ होता है। इसे लागू करने के लिए, हम कीवर्ड परिभाषित होने पर संरचना में एक Inputफ़ील्ड जोड़ देंगे mapData।

  struct Input { float4 color : COLOR; float3 worldPos; float3 terrain; float4 visibility; #if defined(SHOW_MAP_DATA) float mapData; #endif };

शीर्ष प्रोग्राम में, हम इन कोशिकाओं के Z चैनल को भरने के लिए उपयोग करते हैं mapData, जैसा कि कोशिकाओं के बीच हमेशा प्रक्षेपित होता है।

  void vert (inout appdata_full v, out Input data) { … #if defined(SHOW_MAP_DATA) data.mapData = cell0.z * v.color.x + cell1.z * v.color.y + cell2.z * v.color.z; #endif }

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

  void surf (Input IN, inout SurfaceOutputStandardSpecular o) { … o.Albedo = c.rgb * grid * _Color * explored; #if defined(SHOW_MAP_DATA) o.Albedo = IN.mapData * grid; #endif … }

वास्तव में एक shader में डेटा स्थानांतरित करने के लिए। हमें उस HexCellShaderDataविधि में जोड़ने की आवश्यकता है जो नीली बनावट डेटा चैनल के लिए कुछ लिखती है। डेटा 0–1 तक सीमित एक एकल फ्लोट मूल्य है।

  public void SetMapData (HexCell cell, float data) { cellTextureData[cell.Index].b = data < 0f ? (byte)0 : (data < 1f ? (byte)(data * 255f) : (byte)255); enabled = true; }

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

  cellTextureData[cell.Index].b = data < 0f ? (byte)0 : (data < 1f ? (byte)(data * 254f) : (byte)254);

एक ही नाम और में एक विधि जोड़ें HexCell। यह अनुरोध को उसके shader डेटा में स्थानांतरित कर देगा।

  public void SetMapData (float data) { ShaderData.SetMapData(this, data); }

कोड के संचालन की जांच करने के लिए, इसे बदलें HexMapGenerator.SetTerrainTypeताकि यह मानचित्र के प्रत्येक सेल का डेटा सेट करे। आइए 0-1 के अंतराल में पूर्णांक से फ्लोट में परिवर्तित ऊंचाई की कल्पना करें। यह सेल की ऊँचाई से न्यूनतम ऊँचाई घटाकर किया जाता है, इसके बाद न्यूनतम ऊँचाई घटाकर न्यूनतम घटाकर। चलो विभाजन को अस्थायी बिंदु बनाते हैं।

  void SetTerrainType () { for (int i = 0; i < cellCount; i++) { … cell.SetMapData( (cell.Elevation - elevationMinimum) / (float)(elevationMaximum - elevationMinimum) ); } }

अब हम सामान्य राहत और चेक बॉक्स का उपयोग कर डेटा के दृश्य के बीच स्विच करने में सक्षम हो जाएगा दिखाएँ मानचित्र डाटा एसेट सामग्री भू-भाग ।

मानचित्र 1208905299, सामान्य भूभाग और ऊंचाइयों का दृश्य।

जलवायु निर्माण

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

  struct ClimateData { public float clouds; }

सभी सेल के लिए जलवायु डेटा ट्रैक करने के लिए एक सूची जोड़ें।

  List<ClimateData> climate = new List<ClimateData>();

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

  void CreateClimate () { climate.Clear(); ClimateData initialData = new ClimateData(); for (int i = 0; i < cellCount; i++) { climate.Add(initialData); } }

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

  public void GenerateMap (int x, int z) { … CreateRegions(); CreateLand(); ErodeLand(); CreateClimate(); SetTerrainType(); … }

बदलें SetTerrainTypeताकि हम सेल ऊंचाई के बजाय क्लाउड डेटा देख सकें। शुरू में, यह एक काले कार्ड की तरह दिखेगा।

  void SetTerrainType () { for (int i = 0; i < cellCount; i++) { … cell.SetMapData(climate[i].clouds); } }

जलवायु में परिवर्तन

जलवायु अनुकरण में पहला कदम वाष्पीकरण है। कितना पानी वाष्पित होना चाहिए? आइए स्लाइडर का उपयोग करके इस मान को नियंत्रित करें। 0 के मान का अर्थ है वाष्पीकरण नहीं, 1 - अधिकतम वाष्पीकरण। डिफ़ॉल्ट रूप से, हम 0.5 का उपयोग करते हैं।

  [Range(0f, 1f)] public float evaporation = 0.5f;

वाष्पीकरण स्लाइडर।

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

  void EvolveClimate (int cellIndex) { HexCell cell = grid.GetCell(cellIndex); ClimateData cellClimate = climate[cellIndex]; if (cell.IsUnderwater) { cellClimate.clouds += evaporation; } climate[cellIndex] = cellClimate; }

प्रत्येक कक्ष के लिए इस विधि को कॉल करें CreateClimate।

  void CreateClimate () { … for (int i = 0; i < cellCount; i++) { EvolveClimate(i); } }

लेकिन यह पर्याप्त नहीं है। एक जटिल सिमुलेशन बनाने के लिए, हमें कई बार कोशिकाओं की जलवायु को आकार देना होगा। हम जितना अधिक बार ऐसा करेंगे, परिणाम उतना ही बेहतर होगा। चलो बस एक स्थिर मूल्य चुनें। मैं 40 चक्र का उपयोग करता हूं।

  for (int cycle = 0; cycle < 40; cycle++) { for (int i = 0; i < cellCount; i++) { EvolveClimate(i); } }

चूंकि हम केवल पानी से घिरे कोशिकाओं के ऊपर बादलों के मूल्य में वृद्धि करते हैं, जिसके परिणामस्वरूप हमें काली भूमि और सफेद जलाशय मिलते हैं।

पानी पर वाष्पीकरण।

बादल छंटना

बादल लगातार एक स्थान पर नहीं होते हैं, खासकर जब अधिक से अधिक पानी वाष्पित हो जाता है। दबाव अंतर हवा को गति देता है, जो हवा के रूप में खुद को प्रकट करता है, जो बादलों को भी स्थानांतरित करता है।

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

  if (cell.IsUnderwater) { cellClimate.clouds += evaporation; } float cloudDispersal = cellClimate.clouds * (1f / 6f); cellClimate.clouds = 0f; climate[cellIndex] = cellClimate;

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

  float cloudDispersal = cellClimate.clouds * (1f / 6f); for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = cell.GetNeighbor(d); if (!neighbor) { continue; } ClimateData neighborClimate = climate[neighbor.Index]; neighborClimate.clouds += cloudDispersal; climate[neighbor.Index] = neighborClimate; } cellClimate.clouds = 0f;

बिखरे हुए बादल।

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

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

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

क्या सभी कोशिकाओं की जलवायु समानांतर में नहीं होनी चाहिए?

, . - , . 40 . - , .

तेज़ी

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

  [Range(0f, 1f)] public float precipitationFactor = 0.25f;

गुणांक स्लाइडर का उपयोग करें।

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

  if (cell.IsUnderwater) { cellClimate.clouds += evaporation; } float precipitation = cellClimate.clouds * precipitationFactor; cellClimate.clouds -= precipitation; float cloudDispersal = cellClimate.clouds * (1f / 6f);

गायब होने वाले बादल।

अब, जब हम प्रत्येक चक्र में 25% बादल नष्ट करते हैं, तो भूमि फिर से लगभग काली हो जाती है। बादल केवल कुछ कदमों के भीतर अंतर्देशीय को स्थानांतरित करने का प्रबंधन करते हैं, जिसके बाद वे अदृश्य हो जाते हैं।

unitypackage

नमी

यद्यपि वर्षा बादलों को नष्ट कर देती है, लेकिन उन्हें जलवायु से पानी नहीं निकालना चाहिए। जमीन पर गिरने के बाद, पानी बच जाता है, केवल एक अलग स्थिति में। यह कई रूपों में मौजूद हो सकता है, जिसे हम आम तौर पर नमी पर विचार करेंगे।

आर्द्रता ट्रैकिंग

हम दो जल स्थितियों: बादलों और आर्द्रता पर नज़र रखकर जलवायु मॉडल में सुधार करने जा रहे हैं। इसे लागू करने के लिए, ClimateDataफ़ील्ड में जोड़ें moisture।

  struct ClimateData { public float clouds, moisture; }

इसके सबसे सामान्यीकृत रूप में, वाष्पीकरण नमी को बादलों में परिवर्तित करने की प्रक्रिया है, कम से कम हमारे सरल जलवायु मॉडल में। इसका मतलब यह है कि वाष्पीकरण एक स्थिर मूल्य नहीं होना चाहिए, लेकिन एक अन्य कारक। इसलिए, refactor- का नाम बदलने evaporationमें evaporationFactor।

  [Range(0f, 1f)] public float evaporationFactor = 0.5f;

जब सेल पानी के नीचे होता है, हम बस घोषणा करते हैं कि आर्द्रता का स्तर 1. है इसका मतलब है कि वाष्पीकरण वाष्पीकरण गुणांक के बराबर है। लेकिन अब हम सुशी कोशिकाओं से वाष्पीकरण भी प्राप्त कर सकते हैं। इस मामले में, हमें वाष्पीकरण की गणना करने, इसे नमी से घटाना और बादलों में परिणाम जोड़ना होगा। उसके बाद, आर्द्रता में वर्षा को जोड़ा जाता है।

  if (cell.IsUnderwater) { cellClimate.moisture = 1f; cellClimate.clouds += evaporationFactor; } else { float evaporation = cellClimate.moisture * evaporationFactor; cellClimate.moisture -= evaporation; cellClimate.clouds += evaporation; } float precipitation = cellClimate.clouds * precipitationFactor; cellClimate.clouds -= precipitation; cellClimate.moisture += precipitation;

चूँकि बादलों को अब जमीन के ऊपर से वाष्पीकरण द्वारा समर्थित किया जाता है, हम उन्हें आगे अंतर्देशीय स्थानांतरित कर सकते हैं। अब जमीन का थोक भूरा हो गया है।

आर्द्रता के वाष्पीकरण के साथ बादल।

आइए इसे बदल दें SetTerrainTypeताकि यह बादलों के बजाय आर्द्रता प्रदर्शित करे, क्योंकि हम इसका उपयोग राहत के प्रकारों को निर्धारित करने के लिए करेंगे।

  cell.SetMapData(climate[i].moisture);

आर्द्रता प्रदर्शन।

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

वर्षा अपवाह

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

  [Range(0f, 1f)] public float runoffFactor = 0.25f;

नाली का स्लाइडर।

हम नदियां पैदा नहीं करेंगे?

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

  float cloudDispersal = cellClimate.clouds * (1f / 6f); float runoff = cellClimate.moisture * runoffFactor * (1f / 6f); for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = cell.GetNeighbor(d); if (!neighbor) { continue; } ClimateData neighborClimate = climate[neighbor.Index]; neighborClimate.clouds += cloudDispersal; int elevationDelta = neighbor.Elevation - cell.Elevation; if (elevationDelta < 0) { cellClimate.moisture -= runoff; neighborClimate.moisture += runoff; } climate[neighbor.Index] = neighborClimate; }

कम ऊंचाई तक पानी की निकासी।

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

  int elevationDelta = neighbor.ViewElevation - cell.ViewElevation;

दृश्यमान ऊंचाई का उपयोग करें।

टपका

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

  [Range(0f, 1f)] public float seepageFactor = 0.125f;

रिसाव स्लाइडर।

सीपेज एक नाली के समान है, सिवाय इसके कि इसका उपयोग तब किया जाता है जब पड़ोसी की सेल के समान ही दृश्यमान ऊंचाई होती है।

  float runoff = cellClimate.moisture * runoffFactor * (1f / 6f); float seepage = cellClimate.moisture * seepageFactor * (1f / 6f); for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { … int elevationDelta = neighbor.ViewElevation - cell.ViewElevation; if (elevationDelta < 0) { cellClimate.moisture -= runoff; neighborClimate.moisture += runoff; } else if (elevationDelta == 0) { cellClimate.moisture -= seepage; neighborClimate.moisture += seepage; } climate[neighbor.Index] = neighborClimate; }

थोड़ा रिसाव जोड़ा।

unitypackage

बारिश का साया

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

हवा

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

  public HexDirection windDirection = HexDirection.NW; [Range(1f, 10f)] public float windStrength = 4f;

हवा की दिशा और शक्ति।

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

  float cloudDispersal = cellClimate.clouds * (1f / (5f + windStrength));

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

  HexDirection mainDispersalDirection = windDirection.Opposite(); float cloudDispersal = cellClimate.clouds * (1f / (5f + windStrength));

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

  ClimateData neighborClimate = climate[neighbor.Index]; if (d == mainDispersalDirection) { neighborClimate.clouds += cloudDispersal * windStrength; } else { neighborClimate.clouds += cloudDispersal; }

उत्तरपश्चिम की हवा, बल 4.

भूमि के ऊपर नमी के वितरण के लिए प्रमुख हवा दिशात्मकता जोड़ती है। हवा जितनी मजबूत होगी, उतना ही शक्तिशाली प्रभाव बनेगा।

पूर्ण ऊंचाई

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

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

  float precipitation = cellClimate.clouds * precipitationFactor; cellClimate.clouds -= precipitation; cellClimate.moisture += precipitation; float cloudMaximum = 1f - cell.ViewElevation / (elevationMaximum + 1f); HexDirection mainDispersalDirection = windDirection.Opposite();

यदि परिणामस्वरूप हमें स्वीकार्य से अधिक बादल मिलते हैं, तो हम बस अतिरिक्त बादलों को आर्द्रता में परिवर्तित करते हैं। वास्तव में, यह है कि हम अतिरिक्त वर्षा को कैसे जोड़ते हैं, जैसा कि वास्तविक पहाड़ों में होता है।

  float cloudMaximum = 1f - cell.ViewElevation / (elevationMaximum + 1f); if (cellClimate.clouds > cloudMaximum) { cellClimate.moisture += cellClimate.clouds - cloudMaximum; cellClimate.clouds = cloudMaximum; }

अधिक ऊँचाई के कारण वर्षा छाया।

unitypackage

हम अनुकरण पूरा करते हैं

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

समानांतर कंप्यूटिंग

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

  List<ClimateData> climate = new List<ClimateData>(); List<ClimateData> nextClimate = new List<ClimateData>();

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

  void CreateClimate () { climate.Clear(); nextClimate.Clear(); ClimateData initialData = new ClimateData(); for (int i = 0; i < cellCount; i++) { climate.Add(initialData); nextClimate.Add(initialData); } for (int cycle = 0; cycle < 40; cycle++) { for (int i = 0; i < cellCount; i++) { EvolveClimate(i); } List<ClimateData> swap = climate; climate = nextClimate; nextClimate = swap; } }

जब कोई सेल अपने पड़ोसी की जलवायु को प्रभावित करता है, तो हमें निम्नलिखित जलवायु डेटा को बदलना होगा, न कि वर्तमान को।

  for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = cell.GetNeighbor(d); if (!neighbor) { continue; } ClimateData neighborClimate = nextClimate[neighbor.Index]; … nextClimate[neighbor.Index] = neighborClimate; }

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

 // cellClimate.clouds = 0f; ClimateData nextCellClimate = nextClimate[cellIndex]; nextCellClimate.moisture += cellClimate.moisture; nextClimate[cellIndex] = nextCellClimate; climate[cellIndex] = new ClimateData();

जब हम ऐसा कर रहे हैं, तो नमी का स्तर अधिकतम 1 पर सेट करें, ताकि भूमि कोशिकाएं पानी के नीचे से गीली न हो सकें।

  nextCellClimate.moisture += cellClimate.moisture; if (nextCellClimate.moisture > 1f) { nextCellClimate.moisture = 1f; } nextClimate[cellIndex] = nextCellClimate;

समानांतर कंप्यूटिंग।

मूल आर्द्रता

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

  [Range(0f, 1f)] public float startingMoisture = 0.1f;

ऊपर मूल आर्द्रता का स्लाइडर है।

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

  ClimateData initialData = new ClimateData(); initialData.moisture = startingMoisture; ClimateData clearData = new ClimateData(); for (int i = 0; i < cellCount; i++) { climate.Add(initialData); nextClimate.Add(clearData); }

मूल आर्द्रता के साथ।

बायोम को परिभाषित करना

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

  void SetTerrainType () { for (int i = 0; i < cellCount; i++) { HexCell cell = grid.GetCell(i); float moisture = climate[i].moisture; if (!cell.IsUnderwater) { if (moisture < 0.2f) { cell.TerrainTypeIndex = 4; } else if (moisture < 0.4f) { cell.TerrainTypeIndex = 0; } else if (moisture < 0.6f) { cell.TerrainTypeIndex = 3; } else if (moisture < 0.8f) { cell.TerrainTypeIndex = 1; } else { cell.TerrainTypeIndex = 2; } } else { cell.TerrainTypeIndex = 2; } cell.SetMapData(moisture); } }

बायोम।

समान वितरण का उपयोग करते समय, परिणाम बहुत अच्छा नहीं है, और यह अप्राकृतिक दिखता है। अन्य थ्रेसहोल्ड का उपयोग करना बेहतर है, उदाहरण के लिए 0.05, 0.12, 0.28 और 0.85।

  if (moisture < 0.05f) { cell.TerrainTypeIndex = 4; } else if (moisture < 0.12f) { cell.TerrainTypeIndex = 0; } else if (moisture < 0.28f) { cell.TerrainTypeIndex = 3; } else if (moisture < 0.85f) { cell.TerrainTypeIndex = 1; }

संशोधित बायोम।

unitypackage

भाग 26: बायोम और नदियाँ

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

इस भाग में, हम नदियों और तापमान के साथ जल चक्र को पूरक करेंगे, साथ ही कोशिकाओं को अधिक दिलचस्प बायोम भी असाइन करेंगे।

ट्यूटोरियल एकता 2017.3.0p3 का उपयोग करके बनाया गया था।

गर्मी और पानी ने नक्शे को जीवंत कर दिया।

नदी का निर्माण

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

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

नदी का प्रवाह कभी-कभी गलत क्यों होता है?

TriangulateWaterShore , . , . , , . , . , , . («»).

  void TriangulateWaterShore ( HexDirection direction, HexCell cell, HexCell neighbor, Vector3 center ) { … if (cell.HasRiverThroughEdge(direction)) { TriangulateEstuary( e1, e2, cell.HasIncomingRiver && cell.IncomingRiver == direction, indices ); } … }

उच्च आर्द्रता कोशिकाओं

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

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

  void SetTerrainType () { for (int i = 0; i < cellCount; i++) { … float data = (float)(cell.Elevation - waterLevel) / (elevationMaximum - waterLevel); cell.SetMapData(data); } }

आर्द्रता और ऊंचाई। डिफ़ॉल्ट सेटिंग्स के साथ बड़ा नक्शा संख्या 1208905299।

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

  float data = moisture * (cell.Elevation - waterLevel) / (elevationMaximum - waterLevel); cell.SetMapData(data);

नदियों के स्रोतों के लिए वजन।

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

  float data = moisture * (cell.Elevation - waterLevel) / (elevationMaximum - waterLevel); if (data > 0.75f) { cell.SetMapData(1f); } else if (data > 0.5f) { cell.SetMapData(0.5f); } else if (data > 0.25f) { cell.SetMapData(0.25f); } // cell.SetMapData(data);

नदी स्रोतों के भार की श्रेणियाँ।

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

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

  void CreateRivers () { List<HexCell> riverOrigins = ListPool<HexCell>.Get(); for (int i = 0; i < cellCount; i++) { HexCell cell = grid.GetCell(i); if (cell.IsUnderwater) { continue; } ClimateData data = climate[i]; float weight = data.moisture * (cell.Elevation - waterLevel) / (elevationMaximum - waterLevel); if (weight > 0.75f) { riverOrigins.Add(cell); riverOrigins.Add(cell); } if (weight > 0.5f) { riverOrigins.Add(cell); } if (weight > 0.25f) { riverOrigins.Add(cell); } } ListPool<HexCell>.Add(riverOrigins); }

इस विधि को कहा जाना चाहिए CreateClimateताकि नमी डेटा हमारे लिए उपलब्ध हो।

  public void GenerateMap (int x, int z) { … CreateRegions(); CreateLand(); ErodeLand(); CreateClimate(); CreateRivers(); SetTerrainType(); … }

वर्गीकरण पूरा करने के बाद, आप मानचित्र पर इसके डेटा के दृश्य से छुटकारा पा सकते हैं।

  void SetTerrainType () { for (int i = 0; i < cellCount; i++) { … // float data = // moisture * (cell.Elevation - waterLevel) / // (elevationMaximum - waterLevel); // if (data > 0.6f) { // cell.SetMapData(1f); // } // else if (data > 0.4f) { // cell.SetMapData(0.5f); // } // else if (data > 0.2f) { // cell.SetMapData(0.25f); // } } }

नदी के बिंदु

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

  [Range(0, 20)] public int riverPercentage = 10;

स्लाइडर प्रतिशत नदियों।

नदी के बिंदुओं को निर्धारित करने के लिए, कोशिकाओं की संख्या के रूप में व्यक्त किया गया है, हमें यह याद रखने की आवश्यकता है कि कितनी भूमि कोशिकाओं में उत्पन्न हुई थी CreateLand।

  int cellCount, landCells; … void CreateLand () { int landBudget = Mathf.RoundToInt(cellCount * landPercentage * 0.01f); landCells = landBudget; for (int guard = 0; guard < 10000; guard++) { … } if (landBudget > 0) { Debug.LogWarning("Failed to use up " + landBudget + " land budget."); landCells -= landBudget; } }

अंदर, CreateRiversनदी के बिंदुओं की संख्या की गणना अब उसी तरह की जा सकती है, जैसे हम करते हैं CreateLand।

  void CreateRivers () { List<HexCell> riverOrigins = ListPool<HexCell>.Get(); for (int i = 0; i < cellCount; i++) { … } int riverBudget = Mathf.RoundToInt(landCells * riverPercentage * 0.01f); ListPool<HexCell>.Add(riverOrigins); }

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

  int riverBudget = Mathf.RoundToInt(landCells * riverPercentage * 0.01f); while (riverBudget > 0 && riverOrigins.Count > 0) { int index = Random.Range(0, riverOrigins.Count); int lastIndex = riverOrigins.Count - 1; HexCell origin = riverOrigins[index]; riverOrigins[index] = riverOrigins[lastIndex]; riverOrigins.RemoveAt(lastIndex); } if (riverBudget > 0) { Debug.LogWarning("Failed to use up river budget."); }

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

  int CreateRiver (HexCell origin) { int length = 0; return length; }

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

  while (riverBudget > 0 && riverOrigins.Count > 0) { … if (!origin.HasRiver) { riverBudget -= CreateRiver(origin); } }

वर्तमान नदियाँ

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

  int CreateRiver (HexCell origin) { int length = 1; HexCell cell = origin; while (!cell.IsUnderwater) { HexDirection direction = (HexDirection)Random.Range(0, 6); cell.SetOutgoingRiver(direction); length += 1; cell = cell.GetNeighbor(direction); } return length; }

बेतरतीब नदियाँ।

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

  List<HexDirection> flowDirections = new List<HexDirection>(); … int CreateRiver (HexCell origin) { int length = 1; HexCell cell = origin; while (!cell.IsUnderwater) { flowDirections.Clear(); for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = cell.GetNeighbor(d); if (!neighbor || neighbor.HasRiver) { continue; } flowDirections.Add(d); } HexDirection direction = // (HexDirection)Random.Range(0, 6); flowDirections[Random.Range(0, flowDirections.Count)]; cell.SetOutgoingRiver(direction); length += 1; cell = cell.GetNeighbor(direction); } return length; }

इस नए दृष्टिकोण के साथ, हमारे पास शून्य उपलब्ध प्रवाह दिशाएं हो सकती हैं। जब ऐसा होता है, तो नदी अब आगे नहीं बह सकती है और समाप्त होनी चाहिए। यदि इस समय लंबाई 1 है, तो इसका मतलब है कि हम मूल सेल से लीक नहीं कर सकते थे, अर्थात्, कोई भी नदी नहीं हो सकती है। इस मामले में, नदी की लंबाई शून्य है।

  flowDirections.Clear(); for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { … } if (flowDirections.Count == 0) { return length > 1 ? length : 0; }

संरक्षित नदियाँ।

नीचे भाग जाओ

अब हम पहले से ही निर्मित नदियों को बचाते हैं, लेकिन हम अभी भी नदियों के पृथक टुकड़े प्राप्त कर सकते हैं। ऐसा इसलिए होता है क्योंकि जब हम ऊंचाइयों को नजरअंदाज करते हैं। हर बार हमने नदी को अधिक ऊंचाई तक प्रवाह करने के लिए मजबूर किया, HexCell.SetOutgoingRiverइस प्रयास को बाधित किया, जिसके कारण नदियों में दरारें आ गईं। इसलिए, हमें उन दिशाओं को भी छोड़ना होगा जिनके कारण नदियाँ बहती हैं।

  if (!neighbor || neighbor.HasRiver) { continue; } int delta = neighbor.Elevation - cell.Elevation; if (delta > 0) { continue; } flowDirections.Add(d);

नीचे बहती नदियाँ।

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

  if (delta > 0) { continue; } if (delta < 0) { flowDirections.Add(d); flowDirections.Add(d); flowDirections.Add(d); } flowDirections.Add(d);

तीखे मोड़ से बचें

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

  int CreateRiver (HexCell origin) { int length = 1; HexCell cell = origin; HexDirection direction = HexDirection.NE; while (!cell.IsUnderwater) { flowDirections.Clear(); for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { … if (delta < 0) { flowDirections.Add(d); flowDirections.Add(d); flowDirections.Add(d); } if ( length == 1 || (d != direction.Next2() && d != direction.Previous2()) ) { flowDirections.Add(d); } flowDirections.Add(d); } if (flowDirections.Count == 0) { return length > 1 ? length : 0; } // HexDirection direction = direction = flowDirections[Random.Range(0, flowDirections.Count)]; cell.SetOutgoingRiver(direction); length += 1; cell = cell.GetNeighbor(direction); } return length; }

यह उन झीलों नदियों की संभावना को बहुत कम कर देता है जो बदसूरत दिखती हैं।

कम तीखे।

नदी का संगम

कभी-कभी यह पता चलता है कि नदी पहले बनी नदी के स्रोत के ठीक बगल में बहती है। यदि इस नदी का स्रोत अधिक ऊंचाई पर नहीं है, तो हम तय कर सकते हैं कि नई नदी पुराने में बहती है। नतीजतन, हमें एक लंबी नदी मिलती है, और दो पड़ोसी नहीं।

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

  HexCell neighbor = cell.GetNeighbor(d); // if (!neighbor || neighbor.HasRiver) { // continue; // } if (!neighbor || neighbor == origin || neighbor.HasIncomingRiver) { continue; } int delta = neighbor.Elevation - cell.Elevation; if (delta > 0) { continue; } if (neighbor.HasOutgoingRiver) { cell.SetOutgoingRiver(d); return length; }

पूलिंग से पहले और बाद में नदियाँ।

दूरी बनाए रखें

चूंकि स्रोत भूमिका के लिए अच्छे उम्मीदवारों को आम तौर पर एक साथ रखा जाता है, इसलिए हमें नदी के समूह मिलेंगे। इसके अलावा, हमारे पास वे नदियाँ हो सकती हैं जो स्रोत को जलाशय के ठीक बगल में ले जाती हैं, जिसके परिणामस्वरूप लंबाई 1 की नदियाँ हो सकती हैं। हम उन स्रोतों को वितरित कर सकते हैं, जो नदी या जलाशय के आसपास के क्षेत्र में हैं। हम चयनित स्रोत के पड़ोसियों को एक लूप के अंदर से दरकिनार करते हैं CreateRivers। यदि हमें कोई पड़ोसी मिलता है जो नियमों का उल्लंघन करता है, तो स्रोत हमें सूट नहीं करता है और हमें इसे छोड़ देना चाहिए।

  while (riverBudget > 0 && riverOrigins.Count > 0) { int index = Random.Range(0, riverOrigins.Count); int lastIndex = riverOrigins.Count - 1; HexCell origin = riverOrigins[index]; riverOrigins[index] = riverOrigins[lastIndex]; riverOrigins.RemoveAt(lastIndex); if (!origin.HasRiver) { bool isValidOrigin = true; for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = origin.GetNeighbor(d); if (neighbor && (neighbor.HasRiver || neighbor.IsUnderwater)) { isValidOrigin = false; break; } } if (isValidOrigin) { riverBudget -= CreateRiver(origin); } }

और यद्यपि नदियाँ अभी भी एक दूसरे के बगल में बहती हैं, वे एक बड़े क्षेत्र को कवर करते हैं।

बिना दूरी और उसके साथ।

हम एक झील के साथ नदी को समाप्त करते हैं

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

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

  while (!cell.IsUnderwater) { int minNeighborElevation = int.MaxValue; flowDirections.Clear(); for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = cell.GetNeighbor(d); // if (!neighbor || neighbor == origin || neighbor.HasIncomingRiver) { // continue; // } if (!neighbor) { continue; } if (neighbor.Elevation < minNeighborElevation) { minNeighborElevation = neighbor.Elevation; } if (neighbor == origin || neighbor.HasIncomingRiver) { continue; } int delta = neighbor.Elevation - cell.Elevation; if (delta > 0) { continue; } … } … }

यदि हम फंस गए हैं, तो सबसे पहले हमें यह जांचना होगा कि क्या हम अभी भी स्रोत पर हैं। यदि हाँ, तो बस नदी को रद्द कर दें। अन्यथा, हम यह देखने के लिए जांच करते हैं कि क्या सभी पड़ोसी कम से कम वर्तमान सेल के रूप में उच्च हैं। यदि ऐसा है, तो हम इस स्तर तक पानी बढ़ा सकते हैं। यह एक सेल से एक झील बनाएगा, जब तक कि सेल की ऊंचाई समान स्तर पर न हो। यदि ऐसा है, तो बस ऊंचाई को जल स्तर से एक स्तर नीचे रखें।

  if (flowDirections.Count == 0) { // return length > 1 ? length : 0; if (length == 1) { return 0; } if (minNeighborElevation >= cell.Elevation) { cell.WaterLevel = minNeighborElevation; if (minNeighborElevation == cell.Elevation) { cell.Elevation = minNeighborElevation - 1; } } break; }

झीलों के बिना और झीलों के साथ नदियों के छोर। इस मामले में, नदियों का प्रतिशत 20 है।

ध्यान दें कि अब हमारे पास पानी के स्तर से ऊपर का पानी हो सकता है जिसका उपयोग मानचित्र बनाने के लिए किया जाता है। वे समुद्र तल से झीलों को निरूपित करेंगे।

अतिरिक्त झीलें

हम झीलों का निर्माण भी कर सकते हैं, भले ही हम अटके न हों। इससे झील के अंदर और बाहर एक नदी बह सकती है। यदि हम अटक नहीं रहे हैं, तो एक झील का निर्माण जल स्तर और फिर वर्तमान सेल ऊंचाई को बढ़ाकर किया जा सकता है, और फिर सेल की ऊंचाई को कम किया जा सकता है। यह केवल तभी लागू होता है जब पड़ोसी की न्यूनतम ऊंचाई कम से कम वर्तमान सेल की ऊंचाई के बराबर हो। हम नदी के चक्र के अंत में और अगले सेल पर जाने से पहले ऐसा करते हैं।

  while (!cell.IsUnderwater) { … if (minNeighborElevation >= cell.Elevation) { cell.WaterLevel = cell.Elevation; cell.Elevation -= 1; } cell = cell.GetNeighbor(direction); }

बिना अतिरिक्त झीलों और उनके साथ।

कई झीलें सुंदर हैं, लेकिन सीमा के बिना हम बहुत सारी झीलें बना सकते हैं। इसलिए, 0.25 के डिफ़ॉल्ट मान के साथ, अतिरिक्त झीलों के लिए एक कस्टम संभावना जोड़ें।

  [Range(0f, 1f)] public float extraLakeProbability = 0.25f;

यदि संभव हो तो वह एक अतिरिक्त झील बनाने की संभावना को नियंत्रित करेगा।

  if ( minNeighborElevation >= cell.Elevation && Random.value < extraLakeProbability ) { cell.WaterLevel = cell.Elevation; cell.Elevation -= 1; }

अतिरिक्त झीलें।

एक से अधिक सेल के साथ झीलों को बनाने के बारे में क्या?

, , , . . : . , . , , , .

unitypackage

तापमान

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

तापमान और अक्षांश

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

  float DetermineTemperature (HexCell cell) { float latitude = (float)cell.coordinates.Z / grid.cellCountZ; return latitude; }

हम तापमान को परिभाषित करते हैं SetTerrainTypeऔर इसे मानचित्र डेटा के रूप में उपयोग करते हैं।

  void SetTerrainType () { for (int i = 0; i < cellCount; i++) { HexCell cell = grid.GetCell(i); float temperature = DetermineTemperature(cell); cell.SetMapData(temperature); float moisture = climate[i].moisture; … } }

तापमान के रूप में अक्षांश, दक्षिणी गोलार्ध।

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

  [Range(0f, 1f)] public float lowTemperature = 0f; [Range(0f, 1f)] public float highTemperature = 1f;

तापमान में गिरावट।

हम रैखिक प्रक्षेप का उपयोग करके तापमान रेंज लागू करते हैं, प्रक्षेप के रूप में अक्षांश का उपयोग करते हैं। चूंकि हम अक्षांश को 0 से 1 के मान के रूप में व्यक्त करते हैं, इसलिए हम इसका उपयोग कर सकते हैं Mathf.LerpUnclamped।

  float DetermineTemperature (HexCell cell) { float latitude = (float)cell.coordinates.Z / grid.cellCountZ; float temperature = Mathf.LerpUnclamped(lowTemperature, highTemperature, latitude); return temperature; }

ध्यान दें कि कम तापमान आवश्यक रूप से उच्च से कम नहीं है। यदि वांछित है, तो आप उन्हें पलट सकते हैं।

गोलार्द्ध

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

  public enum HemisphereMode { Both, North, South } public HemisphereMode hemisphere;

गोलार्ध की पसंद।

यदि हमें उत्तरी गोलार्ध की आवश्यकता है, तो हम केवल अक्षांश को फ्लिप कर सकते हैं, इसे 1 से घटा सकते हैं। दोनों गोलार्द्धों का अनुकरण करने के लिए, ध्रुव नक्शे के नीचे और ऊपर होना चाहिए, और भूमध्य रेखा मध्य में होनी चाहिए। आप अक्षांश को दोगुना करके ऐसा कर सकते हैं, जबकि निचले गोलार्ध को सही ढंग से संसाधित किया जाएगा, और ऊपरी हिस्से में 1 से 2 का अक्षांश होगा। इसे ठीक करने के लिए, हम अक्षांश को 1 से अधिक होने पर 2 से घटाते हैं।

  float DetermineTemperature (HexCell cell) { float latitude = (float)cell.coordinates.Z / grid.cellCountZ; if (hemisphere == HemisphereMode.Both) { latitude *= 2f; if (latitude > 1f) { latitude = 2f - latitude; } } else if (hemisphere == HemisphereMode.North) { latitude = 1f - latitude; } float temperature = Mathf.LerpUnclamped(lowTemperature, highTemperature, latitude); return temperature; }

दोनों गोलार्ध।

यह ध्यान देने योग्य है कि इससे एक विदेशी मानचित्र बनाने की संभावना पैदा होती है जिसमें भूमध्य रेखा ठंडी होती है और ध्रुव गर्म होते हैं।

अधिक ठंड

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

  float temperature = Mathf.LerpUnclamped(lowTemperature, highTemperature, latitude); temperature *= 1f - (cell.ViewElevation - waterLevel) / (elevationMaximum - waterLevel + 1f); return temperature;

ऊंचाई तापमान को प्रभावित करती है।

तापमान में उतार-चढ़ाव

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

  [Range(0f, 1f)] public float temperatureJitter = 0.1f;

तापमान में उतार-चढ़ाव स्लाइडर।

इस तरह के उतार-चढ़ाव को थोड़े स्थानीय बदलावों के साथ सहज होना चाहिए। आप इसके लिए हमारे शोर बनावट का उपयोग कर सकते हैं। हम HexMetrics.SampleNoiseएक तर्क और सेल की स्थिति के रूप में उपयोग करेंगे, जिसे 0.1 से बढ़ाया जाएगा। चलो चैनल डब्ल्यू लेते हैं, इसे केंद्र करते हैं और इसे दोलन के गुणांक द्वारा स्केल करते हैं। फिर हम इस मान को पहले से परिकलित तापमान में जोड़ते हैं।

  temperature *= 1f - (cell.ViewElevation - waterLevel) / (elevationMaximum - waterLevel + 1f); temperature += (HexMetrics.SampleNoise(cell.Position * 0.1f).w * 2f - 1f) * temperatureJitter; return temperature;

0.1 और 1. के मानों के साथ तापमान में उतार-चढ़ाव।

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

  int temperatureJitterChannel; … void SetTerrainType () { temperatureJitterChannel = Random.Range(0, 4); for (int i = 0; i < cellCount; i++) { … } } float DetermineTemperature (HexCell cell) { … float jitter = HexMetrics.SampleNoise(cell.Position * 0.1f)[temperatureJitterChannel]; temperature += (jitter * 2f - 1f) * temperatureJitter; return temperature; }

अधिकतम बल के साथ विभिन्न तापमान में उतार-चढ़ाव।

unitypackage

बायोम

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

बायोम मैट्रिक्स

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

पहले, हमने पाँच नमी अंतरालों के आधार पर ऊंचाई के प्रकार सौंपे। हम केवल सूखी पट्टी को 0.05 से कम करते हैं, और बाकी को बचाते हैं। तापमान बैंड के लिए हम 0.1, 0.3, 0.6 और अधिक का उपयोग करते हैं। सुविधा के लिए, हम इन मूल्यों को स्थिर सरणियों में सेट करेंगे।

  static float[] temperatureBands = { 0.1f, 0.3f, 0.6f }; static float[] moistureBands = { 0.12f, 0.28f, 0.85f };

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

  struct Biome { public int terrain; public Biome (int terrain) { this.terrain = terrain; } }

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

  static Biome[] biomes = { new Biome(0), new Biome(4), new Biome(4), new Biome(4), new Biome(0), new Biome(2), new Biome(2), new Biome(2), new Biome(0), new Biome(1), new Biome(1), new Biome(1), new Biome(0), new Biome(1), new Biome(1), new Biome(1) };

एक आयामी सरणी के सूचकांकों के साथ बायोम का मैट्रिक्स।

बायोम परिभाषा

SetTerrainTypeबायोम में कोशिकाओं को निर्धारित करने के लिए , हम आवष्यक मैट्रिक्स आवृत्तियों को निर्धारित करने के लिए चक्र में तापमान और आर्द्रता की सीमाओं के आसपास जाएंगे। हम उन्हें वांछित बायोम प्राप्त करने और सेल टोपोग्राफी के प्रकार को निर्दिष्ट करने के लिए उपयोग करते हैं।

  void SetTerrainType () { temperatureJitterChannel = Random.Range(0, 4); for (int i = 0; i < cellCount; i++) { HexCell cell = grid.GetCell(i); float temperature = DetermineTemperature(cell); // cell.SetMapData(temperature); float moisture = climate[i].moisture; if (!cell.IsUnderwater) { // if (moisture < 0.05f) { // cell.TerrainTypeIndex = 4; // } // … // else { // cell.TerrainTypeIndex = 2; // } int t = 0; for (; t < temperatureBands.Length; t++) { if (temperature < temperatureBands[t]) { break; } } int m = 0; for (; m < moistureBands.Length; m++) { if (moisture < moistureBands[m]) { break; } } Biome cellBiome = biomes[t * 4 + m]; cell.TerrainTypeIndex = cellBiome.terrain; } else { cell.TerrainTypeIndex = 2; } } }

एक बायोम मैट्रिक्स पर आधारित राहत।

बायोम सेटअप

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

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

  void SetTerrainType () { temperatureJitterChannel = Random.Range(0, 4); int rockDesertElevation = elevationMaximum - (elevationMaximum - waterLevel) / 2; for (int i = 0; i < cellCount; i++) { … if (!cell.IsUnderwater) { … Biome cellBiome = biomes[t * 4 + m]; if (cellBiome.terrain == 0) { if (cell.Elevation >= rockDesertElevation) { cellBiome.terrain = 3; } } cell.TerrainTypeIndex = cellBiome.terrain; } else { cell.TerrainTypeIndex = 2; } } }

सैंडी और चट्टानी रेगिस्तान।

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

  if (cellBiome.terrain == 0) { if (cell.Elevation >= rockDesertElevation) { cellBiome.terrain = 3; } } else if (cell.Elevation == elevationMaximum) { cellBiome.terrain = 4; }

अधिकतम ऊंचाई पर हिमपात।

पौधों

अब चलो बायोम बनाते हैं पौधे कोशिकाओं के स्तर का निर्धारण करते हैं। ऐसा करने के लिए, Biomeपौधों के क्षेत्र में जोड़ें और इसे कंस्ट्रक्टर में शामिल करें।

  struct Biome { public int terrain, plant; public Biome (int terrain, int plant) { this.terrain = terrain; this.plant = plant; } }

सबसे ठंडे और सूखे बायोम में पौधे बिल्कुल नहीं होंगे। अन्य सभी मामलों में, गर्म और जलवायु को गीला कर देता है, अधिक पौधे। आर्द्रता का दूसरा स्तंभ सबसे गर्म पंक्ति के लिए पौधों का केवल पहला स्तर प्राप्त करता है, इसलिए [0, 0, 0, 1]। तीसरा स्तंभ बर्फ के अपवाद के साथ एक स्तर को बढ़ाता है, अर्थात, [0, 1, 1, 2]। और wettest कॉलम उन्हें फिर से बढ़ाता है, अर्थात, यह निकला [0, 2, 2, 3]। biomesप्लांट कॉन्फ़िगरेशन को इसमें जोड़कर सरणी बदलें ।

  static Biome[] biomes = { new Biome(0, 0), new Biome(4, 0), new Biome(4, 0), new Biome(4, 0), new Biome(0, 0), new Biome(2, 0), new Biome(2, 1), new Biome(2, 2), new Biome(0, 0), new Biome(1, 0), new Biome(1, 1), new Biome(1, 2), new Biome(0, 0), new Biome(1, 1), new Biome(1, 2), new Biome(1, 3) };

पौधों के स्तर के साथ बायोम का मैट्रिक्स।

अब हम सेल के लिए पौधों का स्तर निर्धारित कर सकते हैं।

  cell.TerrainTypeIndex = cellBiome.terrain; cell.PlantLevel = cellBiome.plant;

पौधों के साथ बायोम।

क्या अब पौधे अलग दिखते हैं?

, . (1, 2, 1) (0.75, 1, 0.75). (1.5, 3, 1.5) (2, 1.5, 2). — (2, 4.5, 2) (2.5, 3, 2.5).

, : (13, 114, 0).

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

  if (cellBiome.terrain == 4) { cellBiome.plant = 0; } else if (cellBiome.plant < 3 && cell.HasRiver) { cellBiome.plant += 1; } cell.TerrainTypeIndex = cellBiome.terrain; cell.PlantLevel = cellBiome.plant;

संशोधित पौधे।

पानी के नीचे बायोम

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

  void SetTerrainType () { … if (!cell.IsUnderwater) { … } else { int terrain; if (cell.Elevation == waterLevel - 1) { terrain = 1; } else if (cell.Elevation >= waterLevel) { terrain = 1; } else if (cell.Elevation < 0) { terrain = 3; } else { terrain = 2; } cell.TerrainTypeIndex = terrain; } } }

पानी के भीतर की विविधता।

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

यह निर्धारित करने के लिए, हम पानी के स्तर से एक कदम नीचे स्थित कोशिकाओं के पड़ोसियों की जांच करेंगे। आइए हम पड़ोसी भूमि कोशिकाओं के साथ चट्टानों और ढलानों द्वारा कनेक्शन की संख्या की गणना करें।

  if (cell.Elevation == waterLevel - 1) { int cliffs = 0, slopes = 0; for ( HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++ ) { HexCell neighbor = cell.GetNeighbor(d); if (!neighbor) { continue; } int delta = neighbor.Elevation - cell.WaterLevel; if (delta == 0) { slopes += 1; } else if (delta > 0) { cliffs += 1; } } terrain = 1; }

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

  if (cell.Elevation == waterLevel - 1) { int cliffs = 0, slopes = 0; for ( HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++ ) { … } if (cliffs + slopes > 3) { terrain = 1; } else if (cliffs > 0) { terrain = 3; } else if (slopes > 0) { terrain = 0; } else { terrain = 1; } }

तट की परिवर्तनशीलता।

अंतिम स्पर्श के रूप में, आइए देखें कि हमारे पास सबसे ठंडे तापमान सीमा में हरे पानी के नीचे की कोशिकाएँ नहीं हैं। ऐसी कोशिकाओं के लिए हम पृथ्वी का उपयोग करते हैं।

  if (terrain == 1 && temperature < temperatureBands[0]) { terrain = 2; } cell.TerrainTypeIndex = terrain;

हमें यादृच्छिक कार्ड उत्पन्न करने का अवसर मिला जो कि कई विन्यास विकल्पों के साथ, काफी दिलचस्प और प्राकृतिक दिखते हैं।

unitypackage

भाग 27: एक कार्ड को फोल्ड करना

हम कार्ड को उन स्तंभों में विभाजित करते हैं जिन्हें स्थानांतरित किया जा सकता है।
कैमरे में कार्ड को केन्द्रित करें।
हम सब कुछ ध्वस्त कर देते हैं।

इस अंतिम भाग में, हम मानचित्र को छोटा करने के लिए समर्थन जोड़ेंगे, पूर्वी और पश्चिमी किनारों को जोड़ेंगे।

ट्यूटोरियल एकता 2017.3.0p3 का उपयोग करके बनाया गया था।

फोल्डिंग से दुनिया गोल हो जाती है।

तह कार्ड

हमारे मानचित्रों का उपयोग विभिन्न आकारों के क्षेत्रों के मॉडल के लिए किया जा सकता है, लेकिन वे हमेशा एक आयताकार आकार तक सीमित होते हैं। हम एक द्वीप या एक पूरे महाद्वीप का नक्शा बना सकते हैं, लेकिन पूरे ग्रह का नहीं। ग्रह गोलाकार हैं, उनकी कोई कठोर सीमा नहीं है जो उनकी सतह पर गति को रोकते हैं। यदि आप एक दिशा में आगे बढ़ना जारी रखते हैं, तो जल्दी या बाद में आप प्रारंभिक बिंदु पर लौट आएंगे।

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

एक सिलेंडर एक गोले का एक खराब अनुमान है, क्योंकि हम डंडे का मॉडल नहीं कर सकते हैं। लेकिन यह कई गेम के डेवलपर्स को पूर्व से पश्चिम की ओर मॉडल ग्रह के नक्शे का उपयोग करने से नहीं रोकता है। ध्रुवीय क्षेत्र बस खेल क्षेत्र का हिस्सा नहीं हैं।

उत्तर और दक्षिण की ओर कैसे मुड़ें?

, . , , . -, -. .

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

वैकल्पिक तह

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

पतन के विकल्प के साथ नए नक्शे का मेनू। चयन को ट्रैक

करने के लिए NewMapMenuफ़ील्ड में जोड़ें , साथ ही इसे बदलने के लिए एक विधि भी। स्विच की स्थिति बदलने पर हमें इस विधि को लागू करने दें।

  bool wrapping = true; … public void ToggleWrapping (bool toggle) { wrapping = toggle; }

जब एक नया मानचित्र अनुरोध किया जाता है, तो हम न्यूनतम विकल्प के मूल्य को पास करते हैं।

  void CreateMap (int x, int z) { if (generateMaps) { mapGenerator.GenerateMap(x, z, wrapping); } else { hexGrid.CreateMap(x, z, wrapping); } HexMapCamera.ValidatePosition(); Close(); }

इसे बदलो HexMapGenerator.GenerateMapताकि यह इस नए तर्क को स्वीकार करे और फिर इसे पास करे HexGrid.CreateMap।

  public void GenerateMap (int x, int z, bool wrapping) { … grid.CreateMap(x, z, wrapping); … }

कोड> हेक्सग्रिड को पता होना चाहिए कि क्या हम ढह रहे हैं, इसलिए इसमें एक फ़ील्ड जोड़ें और इसे CreateMapसेट करें। अन्य वर्गों को ग्रिड कम से कम होने के आधार पर अपने तर्क को बदलना चाहिए, इसलिए हम क्षेत्र को सामान्य बनाएंगे। इसके अलावा, यह आपको निरीक्षक के माध्यम से डिफ़ॉल्ट मान सेट करने की अनुमति देता है।

  public int cellCountX = 20, cellCountZ = 15; public bool wrapping; … public bool CreateMap (int x, int z, bool wrapping) { … cellCountX = x; cellCountZ = z; this.wrapping = wrapping; … }

HexGridCreateMapदो स्थानों पर खुद को बुलाता है । हम बस पतन के तर्क के लिए अपने स्वयं के क्षेत्र का उपयोग कर सकते हैं।

  void Awake () { … CreateMap(cellCountX, cellCountZ, wrapping); } … public void Load (BinaryReader reader, int header) { … if (x != cellCountX || z != cellCountZ) { if (!CreateMap(x, z, wrapping)) { return; } } … }

डिफ़ॉल्ट रूप से ग्रिड तह स्विच चालू है।

बचत और लोडिंग

चूंकि तह प्रत्येक कार्ड के लिए सेट है, इसलिए इसे सहेजा और लोड किया जाना चाहिए। इसका मतलब है कि आपको फ़ाइल सहेजने के प्रारूप को बदलने की आवश्यकता है, इसलिए संस्करण में निरंतर वृद्धि करें SaveLoadMenu।

  const int mapFileVersion = 5;

बचत करते समय, HexGridमानचित्र के आकार के बाद इसे बूलियन फोल्डिंग मान लिखने दें।

  public void Save (BinaryWriter writer) { writer.Write(cellCountX); writer.Write(cellCountZ); writer.Write(wrapping); … }

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

  public void Load (BinaryReader reader, int header) { ClearPath(); ClearUnits(); int x = 20, z = 15; if (header >= 1) { x = reader.ReadInt32(); z = reader.ReadInt32(); } bool wrapping = header >= 5 ? reader.ReadBoolean() : false; if (x != cellCountX || z != cellCountZ || this.wrapping != wrapping) { if (!CreateMap(x, z, wrapping)) { return; } } … }

तह मेट्रिक्स

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

  public static int wrapSize; public static bool Wrapping { get { return wrapSize > 0; } }

हमें प्रत्येक कॉल के लिए तह आकार निर्धारित करने की आवश्यकता है HexGrid.CreateMap।

  public bool CreateMap (int x, int z, bool wrapping) { … this.wrapping = wrapping; HexMetrics.wrapSize = wrapping ? cellCountX : 0; … }

चूँकि यह डेटा प्ले मोड में पुनःसंयोजन से नहीं बचेगा, हम इसे इसमें सेट करेंगे OnEnable।

  void OnEnable () { if (!HexMetrics.noiseSource) { HexMetrics.noiseSource = noiseSource; HexMetrics.InitializeHashGrid(seed); HexUnit.unitPrefab = unitPrefab; HexMetrics.wrapSize = wrapping ? cellCountX : 0; ResetVisibility(); } }

सेल की चौड़ाई

बंधनेवाला कार्ड के साथ काम करते समय, हमें अक्सर एक्स अक्ष के साथ स्थिति से निपटना पड़ता है, कोशिकाओं की चौड़ाई में मापा जाता है। यद्यपि इसका उपयोग इसके लिए किया जा सकता है HexMetrics.innerRadius * 2f, लेकिन यह अधिक सुविधाजनक होगा यदि हम हर बार गुणन को जोड़ने के लिए नहीं थे। तो चलिए एक स्थिरांक जोड़ते हैं HexMetrics.innerDiameter।

  public const float innerRadius = outerRadius * outerToInner; public const float innerDiameter = innerRadius * 2f;

हम पहले से ही तीन स्थानों पर व्यास का उपयोग कर सकते हैं। सबसे पहले, HexGrid.CreateCellजब एक नए सेल की स्थिति।

  void CreateCell (int x, int z, int i) { Vector3 position; position.x = (x + z * 0.5f - z / 2) * HexMetrics.innerDiameter; … }

दूसरे, HexMapCameraकैमरे की स्थिति को सीमित करने में।

  Vector3 ClampPosition (Vector3 position) { float xMax = (grid.cellCountX - 0.5f) * HexMetrics.innerDiameter; position.x = Mathf.Clamp(position.x, 0f, xMax); … }

और HexCoordinatesस्थिति से निर्देशांक में रूपांतरण में भी ।

  public static HexCoordinates FromPosition (Vector3 position) { float x = position.x / HexMetrics.innerDiameter; … }

unitypackage

कार्ड केंद्रित

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

नक्शा टुकड़ा कॉलम

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

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

चूँकि हम एक ही समय में टुकड़ों के संपूर्ण स्तंभों को आगे बढ़ा रहे हैं, इसलिए प्रत्येक समूह के लिए एक मूल स्तंभ ऑब्जेक्ट बनाकर उन्हें समूहित करें। इन ऑब्जेक्ट्स के लिए एक सरणी जोड़ें HexGrid, और हम इसे प्रारंभ करेंगे CreateChunks। हम उन्हें केवल कंटेनरों के रूप में उपयोग करेंगे, इसलिए हमें केवल उनके घटकों के लिंक को ट्रैक करने की आवश्यकता है Transform। टुकड़ों के मामले में, उनके प्रारंभिक स्थान ग्रिड निर्देशांक के स्थानीय मूल में स्थित हैं।

  Transform[] columns; … void CreateChunks () { columns = new Transform[chunkCountX]; for (int x = 0; x < chunkCountX; x++) { columns[x] = new GameObject("Column").transform; columns[x].SetParent(transform, false); } … }

अब टुकड़ा ग्रिड के नहीं बल्कि संबंधित कॉलम का एक बच्चा बन जाना चाहिए।

  void CreateChunks () { … chunks = new HexGridChunk[chunkCountX * chunkCountZ]; for (int z = 0, i = 0; z < chunkCountZ; z++) { for (int x = 0; x < chunkCountX; x++) { HexGridChunk chunk = chunks[i++] = Instantiate(chunkPrefab); chunk.transform.SetParent(columns[x], false); } } }

खंड स्तंभों में बांटे गए।

चूँकि सभी टुकड़े अब स्तंभों के बच्चे बन गए हैं, CreateMapयह हमारे लिए सभी स्तंभों को सीधे नष्ट करने के लिए पर्याप्त है, टुकड़े नहीं। तो हम बेटी के टुकड़े से छुटकारा पा लेंगे।

  public bool CreateMap (int x, int z, bool wrapping) { … if (columns != null) { for (int i = 0; i < columns.Length; i++) { Destroy(columns[i].gameObject); } } … }

टेलीपोर्ट कॉलम

पैरामीटर के रूप में स्थिति X के साथ HexGridनई विधि में जोड़ें CenterMap। यूनिटी इकाइयों में टुकड़े की चौड़ाई से विभाजित करते हुए, स्थिति को कॉलम इंडेक्स में बदलें। यह उस स्तंभ का सूचकांक होगा जिसमें कैमरा वर्तमान में स्थित है, अर्थात यह मानचित्र का केंद्र स्तंभ होगा।

  public void CenterMap (float xPosition) { int centerColumnIndex = (int) (xPosition / (HexMetrics.innerDiameter * HexMetrics.chunkSizeX)); }

यह हमारे लिए मानचित्र का दृश्य बदलने के लिए पर्याप्त है जब केंद्रीय स्तंभ का सूचकांक बदलता है। तो चलिए इसे मैदान में ट्रैक करते हैं। हम मानचित्र बनाते समय डिफ़ॉल्ट मान when1 का उपयोग करते हैं ताकि नए मानचित्र हमेशा केंद्रित रहें।

  int currentCenterColumnIndex = -1; … public bool CreateMap (int x, int z, bool wrapping) { … this.wrapping = wrapping; currentCenterColumnIndex = -1; … } … public void CenterMap (float xPosition) { int centerColumnIndex = (int) (xPosition / (HexMetrics.innerDiameter * HexMetrics.chunkSizeX)); if (centerColumnIndex == currentCenterColumnIndex) { return; } currentCenterColumnIndex = centerColumnIndex; }

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

  currentCenterColumnIndex = centerColumnIndex; int minColumnIndex = centerColumnIndex - chunkCountX / 2; int maxColumnIndex = centerColumnIndex + chunkCountX / 2;

ध्यान दें कि ये सूचकांक प्राकृतिक अधिकतम कॉलम इंडेक्स की तुलना में नकारात्मक या अधिक हो सकते हैं। न्यूनतम शून्य तभी होता है जब कैमरा मानचित्र के प्राकृतिक केंद्र के पास होता है। हमारा काम स्तंभों को स्थानांतरित करना है ताकि वे इन सापेक्ष सूचकांकों के अनुरूप हों। यह लूप में प्रत्येक कॉलम के स्थानीय एक्स समन्वय को बदलकर किया जा सकता है।

  int minColumnIndex = centerColumnIndex - chunkCountX / 2; int maxColumnIndex = centerColumnIndex + chunkCountX / 2; Vector3 position; position.y = position.z = 0f; for (int i = 0; i < columns.Length; i++) { position.x = 0f; columns[i].localPosition = position; }

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

  for (int i = 0; i < columns.Length; i++) { if (i < minColumnIndex) { position.x = chunkCountX * (HexMetrics.innerDiameter * HexMetrics.chunkSizeX); } else if (i > maxColumnIndex) { position.x = chunkCountX * -(HexMetrics.innerDiameter * HexMetrics.chunkSizeX); } else { position.x = 0f; } columns[i].localPosition = position; }

कैमरा चाल

बदलें HexMapCamera.AdjustPositionताकि जब एक ढहने वाले कार्ड के साथ काम किया जाए, तो वह ClampPositionकॉल करता है WrapPosition। सबसे पहले, बस नई विधि को WrapPositionडुप्लिकेट बनाएं ClampPosition, लेकिन एकमात्र अंतर के साथ: अंत में, यह कॉल करेगा CenterMap।

  void AdjustPosition (float xDelta, float zDelta) { … transform.localPosition = grid.wrapping ? WrapPosition(position) : ClampPosition(position); } … Vector3 WrapPosition (Vector3 position) { float xMax = (grid.cellCountX - 0.5f) * HexMetrics.innerDiameter; position.x = Mathf.Clamp(position.x, 0f, xMax); float zMax = (grid.cellCountZ - 1) * (1.5f * HexMetrics.outerRadius); position.z = Mathf.Clamp(position.z, 0f, zMax); grid.CenterMap(position.x); return position; }

ताकि कार्ड तुरंत केंद्रित हो, हम OnEnableविधि कहते हैं ValidatePosition।

  void OnEnable () { instance = this; ValidatePosition(); }

कैमरे पर केंद्रित करते समय बाएँ और दाएँ ले जाएँ।

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

कैमरे को ध्वस्त करने के लिए, हम इसके एक्स समन्वय के प्रतिबंध को हटा देते हैं WrapPosition। इसके बजाय, हम शून्य के नीचे रहते हुए, मानचित्र की चौड़ाई द्वारा X निर्देशांक को बढ़ाते रहेंगे और इसे कम करेंगे, जबकि यह मानचित्र की चौड़ाई से बड़ा है।

  Vector3 WrapPosition (Vector3 position) { // float xMax = (grid.cellCountX - 0.5f) * HexMetrics.innerDiameter; // position.x = Mathf.Clamp(position.x, 0f, xMax); float width = grid.cellCountX * HexMetrics.innerDiameter; while (position.x < 0f) { position.x += width; } while (position.x > width) { position.x -= width; } float zMax = (grid.cellCountZ - 1) * (1.5f * HexMetrics.outerRadius); position.z = Mathf.Clamp(position.z, 0f, zMax); grid.CenterMap(position.x); return position; }

रोल-अप कैमरा नक्शे के साथ चलता है।

बंधनेवाला shader बनावट

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

हम इस समस्या को उन टाइलों में प्रकट करके हल कर सकते हैं जो टुकड़े के आकार के गुणक हैं। खंड आकार में स्थिरांक से गणना की जाती है HexMetrics, तो चलिए HexMetrics.cginc shader बनाते हैं जिसमें फ़ाइल शामिल है और उसमें संबंधित परिभाषाएँ चिपकाएँ। मूल टाइल पैमाने की गणना टुकड़े के आकार और कोशिका के बाहरी त्रिज्या से की जाती है। यदि आप अन्य मीट्रिक का उपयोग करते हैं, तो आपको तदनुसार फ़ाइल को संशोधित करना होगा।

 #define OUTER_TO_INNER 0.866025404 #define OUTER_RADIUS 10 #define CHUNK_SIZE_X 5 #define TILING_SCALE (1 / (CHUNK_SIZE_X * 2 * OUTER_RADIUS / OUTER_TO_INNER))

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

शेडर में यूवी स्केल के रूप में 0.02 का उपयोग किया। इसके बजाय, हम दोगुने टाइलिंग स्केल का उपयोग कर सकते हैं, जो 0.01732050808 है। पैमाने से थोड़ा कम प्राप्त किया गया था, और बनावट का स्तर थोड़ा बढ़ गया है, लेकिन नेत्रहीन यह अदृश्य है।

  #include "../HexMetrics.cginc" #include "../HexCellData.cginc" … float4 GetTerrainColor (Input IN, int index) { float3 uvw = float3( IN.worldPos.xz * (2 * TILING_SCALE), IN.terrain[index] ); … }

यूवी शोर के लिए रोड्स शेडर में , हमने 0.025 के पैमाने का उपयोग किया। इसके बजाय, आप ट्रिपल टाइलिंग स्केल का उपयोग कर सकते हैं। यह हमें 0.02598076212 देता है, जो काफी करीब है।

  #include "HexMetrics.cginc" #include "HexCellData.cginc" … void surf (Input IN, inout SurfaceOutputStandardSpecular o) { float4 noise = tex2D(_MainTex, IN.worldPos.xz * (3 * TILING_SCALE)); … }

अंत में, Water.cginc पर हमने फोम के लिए 0.015 और तरंगों के लिए 0.025 का उपयोग किया। यहां हम इन मूल्यों को फिर से दोगुनी और तिगुनी स्केलिंग के साथ बदल सकते हैं।

 #include "HexMetrics.cginc" float Foam (float shore, float2 worldXZ, sampler2D noiseTex) { shore = sqrt(shore) * 0.9; float2 noiseUV = worldXZ + _Time.y * 0.25; float4 noise = tex2D(noiseTex, noiseUV * (2 * TILING_SCALE)); … } … float Waves (float2 worldXZ, sampler2D noiseTex) { float2 uv1 = worldXZ; uv1.y += _Time.y; float4 noise1 = tex2D(noiseTex, uv1 * (3 * TILING_SCALE)); float2 uv2 = worldXZ; uv2.x += _Time.y; float4 noise2 = tex2D(noiseTex, uv2 * (3 * TILING_SCALE)); … }

unitypackage

पूर्व और पश्चिम का मिलन

इस स्तर पर, नक्शे को छोटा करने का एकमात्र दृश्य सबूत पूर्वी और पश्चिमी स्तंभों के बीच एक छोटा सा अंतर है। यह अंतर इसलिए होता है क्योंकि हमने अभी तक तह के बिना नक्शे के विपरीत किनारों पर कोशिकाओं के बीच किनारों और कोणों के कनेक्शन को त्रिकोणित नहीं किया है।

किनारे पर जगह।

तह पड़ोसी

पूर्व-पश्चिम कनेक्शन को त्रिकोणीय बनाने के लिए, हमें एक दूसरे के विपरीत पक्षों पर कोशिकाओं को बनाने की आवश्यकता है। अब तक हम ऐसा नहीं कर रहे हैं, क्योंकि HexGrid.CreateCellई - डब्ल्यू कनेक्शन पिछले सेल के साथ ही स्थापित किया गया है यदि एक्स में इसका सूचकांक शून्य से अधिक है। इस कनेक्शन को ढहाने के लिए, हमें मानचित्र को मोड़ते समय पंक्ति के अंतिम सेल को पहली पंक्ति के साथ उसी पंक्ति में जोड़ना होगा।

  void CreateCell (int x, int z, int i) { … if (x > 0) { cell.SetNeighbor(HexDirection.W, cells[i - 1]); if (wrapping && x == cellCountX - 1) { cell.SetNeighbor(HexDirection.E, cells[i - x]); } } … }

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

यौगिक ई - डब्ल्यू।

हमें NE - SW लिंक को भी संक्षिप्त करना होगा। यह पिछली पंक्ति के अंतिम कक्षों के साथ प्रत्येक पंक्ति के पहले सेल को जोड़कर भी किया जा सकता है। यह सिर्फ पिछली सेल होगी।

  if (z > 0) { if ((z & 1) == 0) { cell.SetNeighbor(HexDirection.SE, cells[i - cellCountX]); if (x > 0) { cell.SetNeighbor(HexDirection.SW, cells[i - cellCountX - 1]); } else if (wrapping) { cell.SetNeighbor(HexDirection.SW, cells[i - 1]); } } else { … } }

एनई - एसडब्ल्यू कनेक्शन।

अंत में, एसई - एनडब्ल्यू कनेक्शन पहले के नीचे प्रत्येक विषम रेखा के अंत में स्थापित होते हैं। इन कोशिकाओं को पिछली पंक्ति के पहले सेल से जुड़ा होना चाहिए।

  if (z > 0) { if ((z & 1) == 0) { … } else { cell.SetNeighbor(HexDirection.SW, cells[i - cellCountX]); if (x < cellCountX - 1) { cell.SetNeighbor(HexDirection.SE, cells[i - cellCountX + 1]); } else if (wrapping) { cell.SetNeighbor( HexDirection.SE, cells[i - cellCountX * 2 + 1] ); } } }

यौगिक एसई - एनडब्ल्यू।

शोर तह

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

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

तापमान में उतार-चढ़ाव के बारे में क्या?

. , . , . , .

यदि हम कार्ड को नहीं गिराते हैं, तो हम HexMetrics.SampleNoiseएक नमूने के साथ प्राप्त कर सकते हैं । लेकिन जब तह यह क्षीणन जोड़ने के लिए आवश्यक है। इसलिए, नमूना वापस करने से पहले, इसे एक चर में सहेजें।

  public static Vector4 SampleNoise (Vector3 position) { Vector4 sample = noiseSource.GetPixelBilinear( position.x * noiseScale, position.z * noiseScale ); return sample; }

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

  Vector4 sample = noiseSource.GetPixelBilinear( position.x * noiseScale, position.z * noiseScale ); if (Wrapping && position.x < innerDiameter) { Vector4 sample2 = noiseSource.GetPixelBilinear( (position.x + wrapSize * innerDiameter) * noiseScale, position.z * noiseScale ); }

एक सेल की चौड़ाई से अधिक पश्चिमी से पूर्वी भाग में सरल रैखिक प्रक्षेप का उपयोग करके क्षीणन का प्रदर्शन किया जाता है।

  if (Wrapping && position.x < innerDiameter) { Vector4 sample2 = noiseSource.GetPixelBilinear( (position.x + wrapSize * innerDiameter) * noiseScale, position.z * noiseScale ); sample = Vector4.Lerp( sample2, sample, position.x * (1f / innerDiameter) ); }

शोर मिश्रण, एक अपूर्ण समाधान।

नतीजतन, हमें एक सटीक मैच नहीं मिलता है, क्योंकि पूर्व की ओर की कुछ कोशिकाओं में नकारात्मक X निर्देशांक हैं। इस क्षेत्र में संपर्क नहीं करने के लिए, चलो संक्रमण क्षेत्र को पश्चिम में आधा सेल चौड़ाई में स्थानांतरित करते हैं।

  if (Wrapping && position.x < innerDiameter * 1.5f) { Vector4 sample2 = noiseSource.GetPixelBilinear( (position.x + wrapSize * innerDiameter) * noiseScale, position.z * noiseScale ); sample = Vector4.Lerp( sample2, sample, position.x * (1f / innerDiameter) - 0.5f ); }

सही क्षीणन।

सेल एडिटिंग

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

ब्रश छंटनी की है।

इसे ठीक करने के लिए, हमें HexCoordinatesतह की रिपोर्ट करने की आवश्यकता है । हम एक्स का मिलान कंस्ट्रक्टर विधि में करके कर सकते हैं। हम जानते हैं कि अक्षीय समन्वय X, Z के आधे समन्वय को घटाकर ऑफ़सेट के X निर्देशांक से प्राप्त किया जाता है। आप इस जानकारी का उपयोग उलटा परिवर्तन करने के लिए कर सकते हैं और जाँच सकते हैं कि क्या शून्य निर्देशांक शून्य से कम है। यदि ऐसा है, तो हम सामने वाले नक्शे के पूर्व की ओर से समन्वय करते हैं। चूँकि प्रत्येक दिशा में हम आधे से अधिक मानचित्रों को टेलीपोर्ट करते हैं, इसलिए हमारे लिए गुना आकार को एक बार एक्स में जोड़ना पर्याप्त होगा। और जब ऑफसेट समन्वय तह आकार से बड़ा होता है, तो हमें एक घटाव प्रदर्शन करने की आवश्यकता होती है।

  public HexCoordinates (int x, int z) { if (HexMetrics.Wrapping) { int oX = x + z / 2; if (oX < 0) { x += HexMetrics.wrapSize; } else if (oX >= HexMetrics.wrapSize) { x -= HexMetrics.wrapSize; } } this.x = x; this.z = z; }

कभी-कभी मानचित्र के नीचे या ऊपर संपादन करते समय मुझे त्रुटियां मिलती हैं
यह तब होता है, जब कोने के विरूपण के कारण, कर्सर नक्शे के बाहर कोशिकाओं की एक पंक्ति में दिखाई देता है। यह एक बग है जो होता है क्योंकि हम HexGrid.GetCellवेक्टर पैरामीटर के साथ निर्देशांक से मेल नहीं खाते हैं । यह एक विधि GetCellको निर्देशांक के साथ लागू करके तय किया जा सकता है जो मापदंडों के रूप में आवश्यक जांच करेगा।

  public HexCell GetCell (Vector3 position) { position = transform.InverseTransformPoint(position); HexCoordinates coordinates = HexCoordinates.FromPosition(position); // int index = // coordinates.X + coordinates.Z * cellCountX + coordinates.Z / 2; // return cells[index]; return GetCell(coordinates); }

तटीय तह

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

पानी की धार गुम।

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

  public int ColumnIndex { get; set; }

इस सूचकांक को असाइन करें HexGrid.CreateCell। यह केवल खंड के आकार से विभाजित एक्स के समन्वय के बराबर है।

  void CreateCell (int x, int z, int i) { … cell.Index = i; cell.ColumnIndex = x / HexMetrics.chunkSizeX; … }

अब हम यह HexGridChunk.TriangulateWaterShoreनिर्धारित कर सकते हैं कि वर्तमान सेल और उसके पड़ोसी के कॉलम इंडेक्स की तुलना करके क्या कम किया गया है। यदि पड़ोसी के कॉलम का सूचकांक एक कदम से कम है, तो हम पश्चिमी तरफ हैं, और पड़ोसी पूर्वी तरफ है। इसलिए, हमें अपने पड़ोसी को पश्चिम की ओर मोड़ने की जरूरत है। वही और विपरीत दिशा में।

  Vector3 center2 = neighbor.Position; if (neighbor.ColumnIndex < cell.ColumnIndex - 1) { center2.x += HexMetrics.wrapSize * HexMetrics.innerDiameter; } else if (neighbor.ColumnIndex > cell.ColumnIndex + 1) { center2.x -= HexMetrics.wrapSize * HexMetrics.innerDiameter; }

तट की पसलियां, लेकिन कोई कोना नहीं।

इसलिए हमने तट की पसलियों की देखभाल की, लेकिन अब तक कोनों के साथ सौदा नहीं किया। हमें अगले पड़ोसी के साथ भी ऐसा ही करने की जरूरत है।

  if (nextNeighbor != null) { Vector3 center3 = nextNeighbor.Position; if (nextNeighbor.ColumnIndex < cell.ColumnIndex - 1) { center3.x += HexMetrics.wrapSize * HexMetrics.innerDiameter; } else if (nextNeighbor.ColumnIndex > cell.ColumnIndex + 1) { center3.x -= HexMetrics.wrapSize * HexMetrics.innerDiameter; } Vector3 v3 = center3 + (nextNeighbor.IsUnderwater ? HexMetrics.GetFirstWaterCorner(direction.Previous()) : HexMetrics.GetFirstSolidCorner(direction.Previous())); … }

उचित रूप से घुमावदार तट।

कार्ड पीढ़ी

पूर्व और पश्चिम की ओर से जोड़ने का विकल्प नक्शों की पीढ़ी को प्रभावित करता है। मानचित्र को छोटा करते समय, पीढ़ी एल्गोरिथ्म को भी कम से कम किया जाना चाहिए। यह एक और नक्शे के निर्माण की ओर ले जाएगा, लेकिन जब गैर-शून्य मैप बॉर्डर एक्स का उपयोग करते हैं , तो तह स्पष्ट नहीं होता है।

डिफ़ॉल्ट सेटिंग्स के साथ बड़ा नक्शा 1208905299। तह के साथ और इसके बिना।

न्यूनतम हो नहीं है का उपयोग करने के भावना मानचित्र सीमा एक्स । लेकिन हम इससे छुटकारा नहीं पा सकते हैं, क्योंकि एक ही समय में क्षेत्रों का विलय हो जाएगा। इसके बजाय कम करते समय, हम केवल एक रीजनबॉर्डर का उपयोग कर सकते हैं ।

बदले HexMapGenerator.CreateRegionsसभी मामलों में की जगह mapBorderXपर borderX। यह नया चर पतन विकल्प के मूल्य के आधार पर regionBorder, या mapBorderX, के बराबर होगा । नीचे मैंने केवल पहले मामले के लिए परिवर्तन दिखाए।

  int borderX = grid.wrapping ? regionBorder : mapBorderX; MapRegion region; switch (regionCount) { default: region.xMin = borderX; region.xMax = grid.cellCountX - borderX; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); break; … }

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

  switch (regionCount) { default: if (grid.wrapping) { borderX = 0; } region.xMin = borderX; region.xMax = grid.cellCountX - borderX; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); break; case 2: if (Random.value < 0.5f) { … } else { if (grid.wrapping) { borderX = 0; } region.xMin = borderX; region.xMax = grid.cellCountX - borderX; region.zMin = mapBorderZ; region.zMax = grid.cellCountZ / 2 - regionBorder; regions.Add(region); region.zMin = grid.cellCountZ / 2 + regionBorder; region.zMax = grid.cellCountZ - mapBorderZ; regions.Add(region); } break; … }

एक क्षेत्र ढह रहा है।

पहली नज़र में, ऐसा लगता है कि सब कुछ सही ढंग से काम करता है, लेकिन वास्तव में सीम के साथ एक अंतर है। यह अधिक ध्यान देने योग्य हो जाता है यदि आप शून्य पर प्रतिशतता का प्रतिशत निर्धारित करते हैं ।

जब कटाव अक्षम होता है, तो राहत पर एक सीम ध्यान देने योग्य हो जाता है।

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

हम बीच की दूरी की गणना करते हैं HexCoordinates, प्रत्येक तीन अक्षों के साथ पूर्ण दूरी को जोड़ते हैं और परिणाम को रोकते हैं। Z के साथ की दूरी हमेशा सही होती है, लेकिन साथ में मोड़ने से X और Y की दूरी प्रभावित हो सकती है। तो चलिए X + Y की एक अलग गणना के साथ शुरू करते हैं।

  public int DistanceTo (HexCoordinates other) { // return // ((x < other.x ? other.x - x : x - other.x) + // (Y < other.Y ? other.Y - Y : Y - other.Y) + // (z < other.z ? other.z - z : z - other.z)) / 2; int xy = (x < other.x ? other.x - x : x - other.x) + (Y < other.Y ? other.Y - Y : Y - other.Y); return (xy + (z < other.z ? other.z - z : z - other.z)) / 2; }

यह निर्धारित करना कि तह मनमानी कोशिकाओं के लिए एक छोटी दूरी बनाता है, यह एक आसान काम नहीं है, तो चलो उन मामलों के लिए X + Y की गणना करें जहां हम पश्चिम की ओर एक और समन्वय कर रहे हैं। यदि मान मूल X + Y से कम है, तो इसका उपयोग करें।

  int xy = (x < other.x ? other.x - x : x - other.x) + (Y < other.Y ? other.Y - Y : Y - other.Y); if (HexMetrics.Wrapping) { other.x += HexMetrics.wrapSize; int xyWrapped = (x < other.x ? other.x - x : x - other.x) + (Y < other.Y ? other.Y - Y : Y - other.Y); if (xyWrapped < xy) { xy = xyWrapped; } }

यदि यह कम दूरी की ओर नहीं जाता है, तो दूसरी दिशा में कम मोड़ना संभव है, इसलिए हम इसकी जांच करेंगे।

  if (HexMetrics.Wrapping) { other.x += HexMetrics.wrapSize; int xyWrapped = (x < other.x ? other.x - x : x - other.x) + (Y < other.Y ? other.Y - Y : Y - other.Y); if (xyWrapped < xy) { xy = xyWrapped; } else { other.x -= 2 * HexMetrics.wrapSize; xyWrapped = (x < other.x ? other.x - x : x - other.x) + (Y < other.Y ? other.Y - Y : Y - other.Y); if (xyWrapped < xy) { xy = xyWrapped; } } }

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

कटाव और कटाव के बिना सही ढंग से तह राहत।

unitypackage

दुनिया की यात्रा

मैप जनरेशन और ट्राइंगुलेशन पर विचार करने के बाद, अब स्क्वाड्स, अन्वेषण और दृश्यता की जाँच करने के लिए आगे बढ़ते हैं।

टेस्ट सीवन

दुनिया भर में एक टीम को ले जाने के दौरान पहली बाधा जो हमारे सामने आती है, वह है नक्शे का किनारा, जिसे खोजा नहीं जा सकता।

कार्ड के सीम की जांच नहीं की जा सकती है।

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

  if (wrapping) { cell.Explorable = z > 0 && z < cellCountZ - 1; } else { cell.Explorable = x > 0 && z > 0 && x < cellCountX - 1 && z < cellCountZ - 1; }

राहत सुविधाओं की दृश्यता

अब देखते हैं कि दृश्यता सीम के साथ काम करती है या नहीं। यह इलाके के लिए काम करता है, लेकिन इलाके की वस्तुओं के लिए नहीं। ऐसा लगता है कि वस्तुओं के ढहने से अंतिम सेल की दृश्यता मिलती है जो ढह नहीं रही थी।

वस्तुओं की गलत दृश्यता।

ऐसा इसलिए होता है क्योंकि HexCellShaderDataक्लैंप मोड का उपयोग बनावट तह मोड के लिए किया जाता है । समस्या को हल करने के लिए, दोहराने के लिए बस इसका क्लैंप मोड बदलें। लेकिन हमें यह केवल यू के निर्देशांक के लिए करने की आवश्यकता है, इसलिए Initializeहम wrapModeUइसे wrapModeVअलग से सेट करेंगे ।

  public void Initialize (int x, int z) { if (cellTexture) { cellTexture.Resize(x, z); } else { cellTexture = new Texture2D( x, z, TextureFormat.RGBA32, false, true ); cellTexture.filterMode = FilterMode.Point; // cellTexture.wrapMode = TextureWrapMode.Clamp; cellTexture.wrapModeU = TextureWrapMode.Repeat; cellTexture.wrapModeV = TextureWrapMode.Clamp; Shader.SetGlobalTexture("_HexCellData", cellTexture); } … }

स्क्वाड और कॉलम

एक और समस्या यह है कि इकाइयाँ अभी तक ढह नहीं रही हैं। जिस कॉलम में वे स्थित हैं, उसे स्थानांतरित करने के बाद, इकाइयां उसी स्थान पर रहती हैं।

इकाई स्थानांतरित नहीं हुई है और गलत तरफ है।

इस समस्या को स्तंभों के बाल तत्वों को बनाकर हल किया जा सकता है, जैसा कि हमने टुकड़ों के साथ किया था। पहले, हम अब उन्हें ग्रिड के तत्काल बच्चे नहीं बनाएंगे HexGrid.AddUnit।

  public void AddUnit (HexUnit unit, HexCell location, float orientation) { units.Add(unit); unit.Grid = this; // unit.transform.SetParent(transform, false); unit.Location = location; unit.Orientation = orientation; }

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

  public void MakeChildOfColumn (Transform child, int columnIndex) { child.SetParent(columns[columnIndex], false); }

प्रॉपर्टी सेट होने पर हम इस विधि को कॉल करेंगे HexUnit.Location।

  public HexCell Location { … set { … Grid.MakeChildOfColumn(transform, value.ColumnIndex); } }

इससे इकाइयाँ बनाने की समस्या हल हो जाती है। लेकिन हमें चलते समय उन्हें वांछित कॉलम में ले जाने की भी आवश्यकता होती है। ऐसा करने के लिए, आपको HexUnit.TravelPathसूचकांक में वर्तमान कॉलम को ट्रैक करने की आवश्यकता है । इस पद्धति की शुरुआत में, यह पथ की शुरुआत में सेल कॉलम का सूचकांक है, या वर्तमान एक है अगर इस कदम को पुनर्संयोजन द्वारा बाधित किया गया था।

  IEnumerator TravelPath () { Vector3 a, b, c = pathToTravel[0].Position; yield return LookAt(pathToTravel[1].Position); // Grid.DecreaseVisibility( // currentTravelLocation ? currentTravelLocation : pathToTravel[0], // VisionRange // ); if (!currentTravelLocation) { currentTravelLocation = pathToTravel[0]; } Grid.DecreaseVisibility(currentTravelLocation, VisionRange); int currentColumn = currentTravelLocation.ColumnIndex; … }

चाल के प्रत्येक पुनरावृत्ति के दौरान, हम जांचेंगे कि क्या अगले कॉलम का सूचकांक अलग है, और यदि ऐसा है, तो हम ऑर्डर के माता-पिता को बदल देंगे।

  int currentColumn = currentTravelLocation.ColumnIndex; float t = Time.deltaTime * travelSpeed; for (int i = 1; i < pathToTravel.Count; i++) { … Grid.IncreaseVisibility(pathToTravel[i], VisionRange); int nextColumn = currentTravelLocation.ColumnIndex; if (currentColumn != nextColumn) { Grid.MakeChildOfColumn(transform, nextColumn); currentColumn = nextColumn; } … }

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

पूरे नक्शे में घुड़दौड़।

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

  for (int i = 1; i < pathToTravel.Count; i++) { currentTravelLocation = pathToTravel[i]; a = c; b = pathToTravel[i - 1].Position; // c = (b + currentTravelLocation.Position) * 0.5f; // Grid.IncreaseVisibility(pathToTravel[i], VisionRange); int nextColumn = currentTravelLocation.ColumnIndex; if (currentColumn != nextColumn) { if (nextColumn < currentColumn - 1) { ax -= HexMetrics.innerDiameter * HexMetrics.wrapSize; bx -= HexMetrics.innerDiameter * HexMetrics.wrapSize; } else if (nextColumn > currentColumn + 1) { ax += HexMetrics.innerDiameter * HexMetrics.wrapSize; bx += HexMetrics.innerDiameter * HexMetrics.wrapSize; } Grid.MakeChildOfColumn(transform, nextColumn); currentColumn = nextColumn; } c = (b + currentTravelLocation.Position) * 0.5f; Grid.IncreaseVisibility(pathToTravel[i], VisionRange); … }

तह के साथ आंदोलन।

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

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

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

  IEnumerator LookAt (Vector3 point) { if (HexMetrics.Wrapping) { float xDistance = point.x - transform.localPosition.x; if (xDistance < -HexMetrics.innerRadius * HexMetrics.wrapSize) { point.x += HexMetrics.innerDiameter * HexMetrics.wrapSize; } else if (xDistance > HexMetrics.innerRadius * HexMetrics.wrapSize) { point.x -= HexMetrics.innerDiameter * HexMetrics.wrapSize; } } … }

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

मैंने अंतिम पैकेज डाउनलोड किया और प्ले मोड में त्रुटियां प्राप्त कीं

, Rotation . . . 5.

मैंने आखिरी पैकेज डाउनलोड किया और ग्राफिक्स स्क्रीनशॉट में उतने सुंदर नहीं हैं

. - .

मैंने आखिरी पैकेज डाउनलोड किया और यह लगातार एक ही कार्ड बनाता है

seed (1208905299), . , Use Fixed Seed .

unitypackage

एकता में षट्कोण मानचित्र: जल चक्र, क्षरण, बायोम, बेलनाकार नक्शा

भाग 24: क्षेत्र और क्षरण

नक्शा सीमा

सीमा का आकार

हम भूमि क्षेत्रों के केंद्रों को सीमित करते हैं

पैंजिया

हम असंभव कार्ड से रक्षा करते हैं

एक कार्ड का विभाजन

मानचित्र क्षेत्र

कई क्षेत्रों

दो क्षेत्रों

चार क्षेत्र

कटाव

कटाव प्रतिशत

क्षरण नष्ट करने वाली कोशिकाओं की खोज करें

कोशिका की कमी

कटाव ट्रैकिंग

हम बहुत जमीन बचाते हैं

त्वरित कटाव

भाग 25: जल चक्र

बादल

डेटा विज़ुअलाइज़ेशन

जलवायु निर्माण

जलवायु में परिवर्तन

बादल छंटना

तेज़ी

नमी

आर्द्रता ट्रैकिंग

वर्षा अपवाह

टपका

बारिश का साया

हवा

पूर्ण ऊंचाई

हम अनुकरण पूरा करते हैं

समानांतर कंप्यूटिंग

मूल आर्द्रता

बायोम को परिभाषित करना

भाग 26: बायोम और नदियाँ

नदी का निर्माण

उच्च आर्द्रता कोशिकाओं

नदी के बिंदु

वर्तमान नदियाँ

नीचे भाग जाओ

तीखे मोड़ से बचें

नदी का संगम

दूरी बनाए रखें

हम एक झील के साथ नदी को समाप्त करते हैं

अतिरिक्त झीलें

तापमान

तापमान और अक्षांश

गोलार्द्ध

अधिक ठंड

तापमान में उतार-चढ़ाव

बायोम

बायोम मैट्रिक्स

बायोम परिभाषा

बायोम सेटअप

पौधों

पानी के नीचे बायोम

भाग 27: एक कार्ड को फोल्ड करना

तह कार्ड

वैकल्पिक तह

बचत और लोडिंग

तह मेट्रिक्स

सेल की चौड़ाई

कार्ड केंद्रित

नक्शा टुकड़ा कॉलम

टेलीपोर्ट कॉलम

कैमरा चाल

बंधनेवाला shader बनावट

पूर्व और पश्चिम का मिलन

तह पड़ोसी

शोर तह

सेल एडिटिंग

तटीय तह

कार्ड पीढ़ी

दुनिया की यात्रा

टेस्ट सीवन

राहत सुविधाओं की दृश्यता

स्क्वाड और कॉलम