एक अनुवादक से: यह लेख हेक्सागोन्स से नक्शे बनाने पर ट्यूटोरियल की एक विस्तृत (27 भागों) श्रृंखला में से पहला है। यह वही है जो ट्यूटोरियल के बहुत अंत में होना चाहिए।

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

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

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

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

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

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

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

भाग 1: हेक्सागोन्स से मेष

सामग्री की तालिका

• वर्गों को हेक्सागोन्स में परिवर्तित करें।
• हेक्सागोन्स के एक ग्रिड को त्रिकोणित करें।
• हम घन निर्देशांक के साथ काम करते हैं।
• हम ग्रिड कोशिकाओं के साथ बातचीत करते हैं।
• एक इन-गेम एडिटर बनाएं।

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

यह ट्यूटोरियल मानता है कि आपने पहले से ही मेष मूल बातें श्रृंखला का अध्ययन किया है, जो प्रक्रियात्मक ग्रिड से शुरू होती है। यह एकता 5.3.1 पर बनाया गया था। श्रृंखला एकता के कई संस्करणों का उपयोग करती है। अंतिम भाग एकता 2017.3.0p3 पर बनाया गया है।


हेक्सागोन्स का एक सरल नक्शा।

हेक्सागोन्स के बारे में

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


चौकोर और उसके पड़ोसी।

कुल में, वर्ग में आठ पड़ोसी हैं। उनमें से चार को वर्ग के किनारे को पार करके प्राप्त किया जा सकता है। ये क्षैतिज और ऊर्ध्वाधर पड़ोसी हैं। अन्य चार को वर्ग के कोने को पार करके प्राप्त किया जा सकता है। ये विकर्ण पड़ोसी हैं।

आसन्न वर्ग ग्रिड कोशिकाओं के केंद्रों के बीच की दूरी क्या है? यदि किनारे की लंबाई 1 है, तो क्षैतिज और ऊर्ध्वाधर पड़ोसियों के लिए उत्तर 1 है। लेकिन विकर्ण पड़ोसियों के लिए जवाब √2 है।

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


षट्कोण और उसके पड़ोसी।

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

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


हेक्सागोन के बाहरी और आंतरिक त्रिज्या।

एक आंतरिक त्रिज्या भी है, जो केंद्र से प्रत्येक किनारे तक की दूरी है। यह पैरामीटर महत्वपूर्ण है क्योंकि पड़ोसियों के केंद्रों के बीच की दूरी इस मान दो बार के बराबर है। भीतर का दायरा है $$$\ frac {\ sqrt {3}} {2}$ बाहरी दायरे से, जो हमारे मामले में है $$$5 \ sqrt {3}$ । सुविधा के लिए इन मापदंडों को एक स्थिर वर्ग में रखें।

using UnityEngine; public static class HexMetrics { public const float outerRadius = 10f; public const float innerRadius = outerRadius * 0.866025404f; } 

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


संभव अभिविन्यास।

  public static Vector3[] corners = { new Vector3(0f, 0f, outerRadius), new Vector3(innerRadius, 0f, 0.5f * outerRadius), new Vector3(innerRadius, 0f, -0.5f * outerRadius), new Vector3(0f, 0f, -outerRadius), new Vector3(-innerRadius, 0f, -0.5f * outerRadius), new Vector3(-innerRadius, 0f, 0.5f * outerRadius) }; 

unitypackage

एक ग्रिड का निर्माण

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

 using UnityEngine; public class HexCell : MonoBehaviour { } 

सबसे सरल से शुरू करने के लिए, एक डिफ़ॉल्ट विमान ऑब्जेक्ट बनाएं, इसमें एक सेल घटक जोड़ें, और इसे सभी प्रीफैब में बदल दें।


एक हेक्सागोनल सेल के प्रीफैब के रूप में एक विमान का उपयोग करना।

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

 using UnityEngine; public class HexGrid : MonoBehaviour { public int width = 6; public int height = 6; public HexCell cellPrefab; } 

षट्भुज मेष वस्तु।

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

चूंकि डिफ़ॉल्ट रूप से विमानों का आकार 10 बाई 10 यूनिट है, इसलिए हम प्रत्येक सेल को इस राशि से स्थानांतरित करेंगे।

  HexCell[] cells; void Awake () { cells = new HexCell[height * width]; for (int z = 0, i = 0; z < height; z++) { for (int x = 0; x < width; x++) { CreateCell(x, z, i++); } } } void CreateCell (int x, int z, int i) { Vector3 position; position.x = x * 10f; position.y = 0f; position.z = z * 10f; HexCell cell = cells[i] = Instantiate<HexCell>(cellPrefab); cell.transform.SetParent(transform, false); cell.transform.localPosition = position; } 

विमानों का वर्ग ग्रिड।

इसलिए हमें वर्ग कोशिकाओं का एक सुंदर ठोस ग्रिड मिला। लेकिन कौन सी सेल कहाँ है? बेशक, यह सत्यापित करना आसान है, लेकिन हेक्सागोन्स के साथ कठिनाइयां हैं। यह सुविधाजनक होगा यदि हम एक साथ सभी कोशिकाओं के निर्देशांक देख सकें।

समन्वय का प्रदर्शन

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

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

अंतिम स्पर्श के रूप में, डायनामिक पिक्सेल प्रति यूनिट 10 तक बढ़ाएं। इसलिए हम गारंटी देते हैं कि टेक्स्ट ऑब्जेक्ट पर्याप्त बनावट रिज़ॉल्यूशन का उपयोग करेंगे।



हेक्सागोन के ग्रिड निर्देशांक के लिए कैनवास।

निर्देशांक प्रदर्शित करने के लिए, एक टेक्स्ट ऑब्जेक्ट ( गेमऑबजेक्ट / यूआई / टेक्स्ट ) बनाएं और इसे प्रीफैब में बदल दें। इसके एंकरों और धुरी को केंद्र में रखें, आकार 5 से 15. तक सेट करें। केंद्र में पाठ को क्षैतिज और लंबवत रूप से भी संरेखित किया जाना चाहिए। फ़ॉन्ट आकार को 4 पर सेट करें। अंत में, हम डिफ़ॉल्ट पाठ का उपयोग नहीं करना चाहते हैं और हम रिच टेक्स्ट का उपयोग नहीं करेंगे। इसके अलावा, हमारे लिए यह मायने नहीं रखता कि क्या Raycast टार्गेट चालू है, क्योंकि हमारे कैनवास के लिए अभी भी इसकी आवश्यकता नहीं है।



Prefab सेल लेबल।

अब हमें ग्रिड को कैनवास और प्रीफैब के बारे में बताने की जरूरत है। using UnityEngine.UI; उसकी स्क्रिप्ट की शुरुआत में जोड़ें using UnityEngine.UI; आसानी से UnityEngine.UI.Text प्रकार का उपयोग करने के लिए। GetComponentInChildren लेबल को एक साझा चर की आवश्यकता होती है, और कैनवास GetComponentInChildren को कॉल करके पाया जा सकता है।

  public Text cellLabelPrefab; Canvas gridCanvas; void Awake () { gridCanvas = GetComponentInChildren<Canvas>(); … } 

कनेक्शन प्रीफैब टैग।

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

  void CreateCell (int x, int z, int i) { … Text label = Instantiate<Text>(cellLabelPrefab); label.rectTransform.SetParent(gridCanvas.transform, false); label.rectTransform.anchoredPosition = new Vector2(position.x, position.z); label.text = x.ToString() + "\n" + z.ToString(); } 

समन्वय का प्रदर्शन।

षट्भुज पदों

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


पड़ोसी हेक्सागोन्स की ज्यामिति।

  position.x = x * (HexMetrics.innerRadius * 2f); position.y = 0f; position.z = z * (HexMetrics.outerRadius * 1.5f); 

हम हेक्सागोन्स के बीच दूरियों के बिना दूरी लागू करते हैं।

बेशक, हेक्सागोन्स की क्रमिक पंक्तियाँ एक दूसरे के बिल्कुल ऊपर स्थित नहीं हैं। प्रत्येक पंक्ति एक्स अक्ष के साथ आंतरिक त्रिज्या के मान से ऑफसेट होती है। यह मान आधे Z को X में जोड़कर प्राप्त किया जा सकता है, और फिर आंतरिक त्रिज्या से दोगुना गुणा किया जा सकता है।

  position.x = (x + z * 0.5f) * (HexMetrics.innerRadius * 2f); 

हेक्सागोन्स का उचित स्थान हीरे के आकार का ग्रिड बनाता है।

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

  position.x = (x + z * 0.5f - z / 2) * (HexMetrics.innerRadius * 2f); 

एक आयताकार क्षेत्र में हेक्सागोन्स का स्थान।

unitypackage

हेक्सागोन रेंडरिंग

कोशिकाओं को सही ढंग से रखने के बाद, हम असली हेक्सागोन्स प्रदर्शित करने के लिए आगे बढ़ सकते हैं। पहले हमें विमानों से छुटकारा पाने की आवश्यकता है, इसलिए हम सेल HexCell से HexCell को छोड़कर सभी घटकों को हटा देंगे।


और कोई विमान नहीं हैं।

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

एक नया HexMesh घटक बनाएं जो हमारे जाल की देखभाल करता है। इसके लिए एक जाली फिल्टर और रेंडरर की आवश्यकता होगी, इसमें जाली और त्रिकोण और त्रिकोण की सूची है।

 using UnityEngine; using System.Collections.Generic; [RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))] public class HexMesh : MonoBehaviour { Mesh hexMesh; List<Vector3> vertices; List<int> triangles; void Awake () { GetComponent<MeshFilter>().mesh = hexMesh = new Mesh(); hexMesh.name = "Hex Mesh"; vertices = new List<Vector3>(); triangles = new List<int>(); } } 

इस घटक के साथ इस जाली के लिए एक नया चाइल्ड ऑब्जेक्ट बनाएं। वह स्वचालित रूप से एक मेष रेंडर प्राप्त करेगा, लेकिन कोई भी सामग्री उसे नहीं सौंपी जाएगी। इसलिए, इसमें डिफ़ॉल्ट सामग्री जोड़ें।



हेक्स मेष वस्तु।

HexGrid अब उसी तरह से अपने षट्भुज जाल को पुनः प्राप्त करने में सक्षम होगा जैसे उसने कैनवास पाया।

  HexMesh hexMesh; void Awake () { gridCanvas = GetComponentInChildren<Canvas>(); hexMesh = GetComponentInChildren<HexMesh>(); … } 

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

  void Start () { hexMesh.Triangulate(cells); } 

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

  public void Triangulate (HexCell[] cells) { hexMesh.Clear(); vertices.Clear(); triangles.Clear(); for (int i = 0; i < cells.Length; i++) { Triangulate(cells[i]); } hexMesh.vertices = vertices.ToArray(); hexMesh.triangles = triangles.ToArray(); hexMesh.RecalculateNormals(); } void Triangulate (HexCell cell) { } 

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

  void AddTriangle (Vector3 v1, Vector3 v2, Vector3 v3) { int vertexIndex = vertices.Count; vertices.Add(v1); vertices.Add(v2); vertices.Add(v3); triangles.Add(vertexIndex); triangles.Add(vertexIndex + 1); triangles.Add(vertexIndex + 2); } 

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

  void Triangulate (HexCell cell) { Vector3 center = cell.transform.localPosition; AddTriangle( center, center + HexMetrics.corners[0], center + HexMetrics.corners[1] ); } 

प्रत्येक कोशिका का पहला त्रिकोण।

यह काम किया है, तो चलो सभी छह त्रिकोण के चारों ओर पाश।

  Vector3 center = cell.transform.localPosition; for (int i = 0; i < 6; i++) { AddTriangle( center, center + HexMetrics.corners[i], center + HexMetrics.corners[i + 1] ); } 

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

  public static Vector3[] corners = { new Vector3(0f, 0f, outerRadius), new Vector3(innerRadius, 0f, 0.5f * outerRadius), new Vector3(innerRadius, 0f, -0.5f * outerRadius), new Vector3(0f, 0f, -outerRadius), new Vector3(-innerRadius, 0f, -0.5f * outerRadius), new Vector3(-innerRadius, 0f, 0.5f * outerRadius), new Vector3(0f, 0f, outerRadius) }; 

पूरी तरह से Hexagons।

unitypackage

षट्कोणीय निर्देशांक

चलो कोशिकाओं के निर्देशांक को फिर से देखें, अब हेक्सागोन्स के ग्रिड के संदर्भ में। Z निर्देशांक ठीक दिखता है, और X समन्वयित zigzags। यह आयताकार क्षेत्र को कवर करने के लिए लाइन ऑफ़सेट का एक साइड इफेक्ट है।


ऑफसेट हाइलाइट की गई शून्य लाइनों के साथ समन्वय करता है।

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

 using UnityEngine; [System.Serializable] public struct HexCoordinates { public int X { get; private set; } public int Z { get; private set; } public HexCoordinates (int x, int z) { X = x; Z = z; } } 

साधारण ऑफसेट निर्देशांक से निर्देशांक का एक सेट बनाने के लिए एक स्थिर विधि जोड़ें। अभी के लिए, हम बस इन निर्देशांक की नकल करेंगे।

  public static HexCoordinates FromOffsetCoordinates (int x, int z) { return new HexCoordinates(x, z); } } 

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

  public override string ToString () { return "(" + X.ToString() + ", " + Z.ToString() + ")"; } public string ToStringOnSeparateLines () { return X.ToString() + "\n" + Z.ToString(); } 

अब हम अपने HexCell घटक के लिए कई निर्देशांक पारित कर सकते हैं।

 public class HexCell : MonoBehaviour { public HexCoordinates coordinates; } 

HexGrid.CreateCell बदलें ताकि यह नए निर्देशांक का उपयोग कर सके।

  HexCell cell = cells[i] = Instantiate<HexCell>(cellPrefab); cell.transform.SetParent(transform, false); cell.transform.localPosition = position; cell.coordinates = HexCoordinates.FromOffsetCoordinates(x, z); Text label = Instantiate<Text>(cellLabelPrefab); label.rectTransform.SetParent(gridCanvas.transform, false); label.rectTransform.anchoredPosition = new Vector2(position.x, position.z); label.text = cell.coordinates.ToStringOnSeparateLines(); 

अब इन एक्स निर्देशांक को फिर से करें ताकि वे एक सीधी धुरी के साथ संरेखित हों। यह क्षैतिज पारी को रद्द करके किया जा सकता है। परिणामी परिणाम को आमतौर पर अक्षीय निर्देशांक कहा जाता है।

  public static HexCoordinates FromOffsetCoordinates (int x, int z) { return new HexCoordinates(x - z / 2, z); } 

अक्षीय निर्देशांक।

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


Y माप दिखाई देता है।

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

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

  public int Y { get { return -X - Z; } } public override string ToString () { return "(" + X.ToString() + ", " + Y.ToString() + ", " + Z.ToString() + ")"; } public string ToStringOnSeparateLines () { return X.ToString() + "\n" + Y.ToString() + "\n" + Z.ToString(); } 

घन निर्देशांक।

इंस्पेक्टर निर्देशांक

प्ले मोड में, ग्रिड कोशिकाओं में से एक का चयन करें। यह पता चला है कि निरीक्षक अपने निर्देशांक प्रदर्शित नहीं करता है, केवल HexCell.coordinates निर्देशांक उपसर्ग लेबल HexCell.coordinates ।


निरीक्षक निर्देशांक प्रदर्शित नहीं करता है।

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

  [SerializeField] private int x, z; public int X { get { return x; } } public int Z { get { return z; } } public HexCoordinates (int x, int z) { this.x = x; this.z = z; } 

X और Z निर्देशांक अब प्रदर्शित होते हैं, लेकिन उन्हें बदला जा सकता है। हमें इसकी आवश्यकता नहीं है, क्योंकि निर्देशांक निश्चित होना चाहिए। यह भी बहुत अच्छा नहीं है कि वे एक-दूसरे के नीचे प्रदर्शित हों।

हम बेहतर कर सकते हैं: HexCoordinates प्रकार के लिए हमारी अपनी संपत्ति दराज को HexCoordinates करें। एक HexCoordinatesDrawer स्क्रिप्ट बनाएं और उसे संपादक फ़ोल्डर में पेस्ट करें, क्योंकि यह स्क्रिप्ट केवल संपादक के लिए है।

वर्ग को UnityEditor.PropertyDrawer विस्तार करना चाहिए और उसे उपयुक्त प्रकार के साथ जोड़ने के लिए UnityEditor.CustomPropertyDrawer विशेषता की आवश्यकता है।

 using UnityEngine; using UnityEditor; [CustomPropertyDrawer(typeof(HexCoordinates))] public class HexCoordinatesDrawer : PropertyDrawer { } 

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

  public override void OnGUI ( Rect position, SerializedProperty property, GUIContent label ) { } 

हम संपत्ति से x और z के मान निकालते हैं, और फिर निर्देशांक का एक नया सेट बनाने के लिए उनका उपयोग करते हैं। फिर हमारे HexCoordinates.ToString पद्धति का उपयोग करके GUI लेबल को चयनित स्थान पर ड्रा करें।

  public override void OnGUI ( Rect position, SerializedProperty property, GUIContent label ) { HexCoordinates coordinates = new HexCoordinates( property.FindPropertyRelative("x").intValue, property.FindPropertyRelative("z").intValue ); GUI.Label(position, coordinates.ToString()); } 

एक उपसर्ग लेबल के बिना निर्देशांक।

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

  position = EditorGUI.PrefixLabel(position, label); GUI.Label(position, coordinates.ToString()); 

एक लेबल के साथ निर्देशांक।

unitypackage

स्पर्श कोशिकाएँ

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

सेल को छूने के लिए, आप माउस कर्सर की स्थिति से किरणों को दृश्य में उत्सर्जित कर सकते हैं। हम मेष विरूपण ट्यूटोरियल में उसी दृष्टिकोण का उपयोग कर सकते हैं।

  void Update () { if (Input.GetMouseButton(0)) { HandleInput(); } } void HandleInput () { Ray inputRay = Camera.main.ScreenPointToRay(Input.mousePosition); RaycastHit hit; if (Physics.Raycast(inputRay, out hit)) { TouchCell(hit.point); } } void TouchCell (Vector3 position) { position = transform.InverseTransformPoint(position); Debug.Log("touched at " + position); } 

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

  MeshCollider meshCollider; void Awake () { GetComponent<MeshFilter>().mesh = hexMesh = new Mesh(); meshCollider = gameObject.AddComponent<MeshCollider>(); … } 

त्रिकोणासन पूरा होने के बाद, कोलाइडर को एक मेष असाइन करें।

  public void Triangulate (HexCell[] cells) { … meshCollider.sharedMesh = hexMesh; } 

अब हम ग्रिड को छू सकते हैं! लेकिन हम किस कोशिका को स्पर्श करते हैं? यह पता लगाने के लिए, हमें स्पर्श स्थिति को हेक्सागोन्स के निर्देशांक में परिवर्तित करना होगा। यह HexCoordinates लिए काम HexCoordinates , इसलिए हम घोषित HexCoordinates कि इसकी एक स्थैतिक FromPosition विधि है।

  public void TouchCell (Vector3 position) { position = transform.InverseTransformPoint(position); HexCoordinates coordinates = HexCoordinates.FromPosition(position); Debug.Log("touched at " + coordinates.ToString()); } 

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

  public static HexCoordinates FromPosition (Vector3 position) { float x = position.x / (HexMetrics.innerRadius * 2f); float y = -x; } 

निश्चित रूप से, यह हमें सही निर्देशांक देगा यदि Z शून्य थे। Z. हर दो लाइनों के साथ आगे बढ़ने पर हमें फिर से शिफ्ट होना चाहिए, हमें एक इकाई द्वारा बाईं ओर शिफ्ट होना चाहिए।

  float offset = position.z / (HexMetrics.outerRadius * 3f); x -= offset; y -= offset; 

परिणामस्वरूप, हमारे x और y मान प्रत्येक सेल के केंद्र में पूर्णांक बनते हैं। इसलिए, उन्हें निकटतम पूर्णांक तक गोल करना, हमें निर्देशांक प्राप्त करना होगा। हम Z की गणना भी करते हैं और इस प्रकार अंतिम निर्देशांक प्राप्त करते हैं।

  int iX = Mathf.RoundToInt(x); int iY = Mathf.RoundToInt(y); int iZ = Mathf.RoundToInt(-x -y); return new HexCoordinates(iX, iZ); 

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

  if (iX + iY + iZ != 0) { Debug.LogWarning("rounding error!"); } return new HexCoordinates(iX, iZ); 

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

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

  if (iX + iY + iZ != 0) { float dX = Mathf.Abs(x - iX); float dY = Mathf.Abs(y - iY); float dZ = Mathf.Abs(-x -y - iZ); if (dX > dY && dX > dZ) { iX = -iY - iZ; } else if (dZ > dY) { iZ = -iX - iY; } } 

हेक्सागोन्स रंग पेज

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

  public Color defaultColor = Color.white; public Color touchedColor = Color.magenta; 

सेल रंग चयन। सामान्य रंग फ़ील्ड में

जोड़ें HexCell।

 public class HexCell : MonoBehaviour { public HexCoordinates coordinates; public Color color; } 

इसे HexGrid.CreateCellडिफ़ॉल्ट रंग को असाइन करें ।

  void CreateCell (int x, int z, int i) { … cell.coordinates = HexCoordinates.FromOffsetCoordinates(x, z); cell.color = defaultColor; … } 

हमें HexMeshरंग जानकारी में भी जोड़ने की आवश्यकता है ।

  List<Color> colors; void Awake () { … vertices = new List<Vector3>(); colors = new List<Color>(); … } public void Triangulate (HexCell[] cells) { hexMesh.Clear(); vertices.Clear(); colors.Clear(); … hexMesh.vertices = vertices.ToArray(); hexMesh.colors = colors.ToArray(); … } 

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

  void Triangulate (HexCell cell) { Vector3 center = cell.transform.localPosition; for (int i = 0; i < 6; i++) { AddTriangle( center, center + HexMetrics.corners[i], center + HexMetrics.corners[i + 1] ); AddTriangleColor(cell.color); } } void AddTriangleColor (Color color) { colors.Add(color); colors.Add(color); colors.Add(color); } 

पर वापस HexGrid.TouchCell। सबसे पहले, सेल के निर्देशांक को सरणी के संबंधित सूचकांक में परिवर्तित करें। चौकोर ग्रिड के लिए, यह चौड़ाई से केवल X प्लस Z गुणा होगा, लेकिन हमारे मामले में, हमें आधे Z की एक ऑफसेट भी जोड़ना होगा। फिर हम सेल लेते हैं, उसका रंग बदलते हैं और फिर से मेष को फिर से बनाते हैं।

  public void TouchCell (Vector3 position) { position = transform.InverseTransformPoint(position); HexCoordinates coordinates = HexCoordinates.FromPosition(position); int index = coordinates.X + coordinates.Z * width + coordinates.Z / 2; HexCell cell = cells[index]; cell.color = touchedColor; hexMesh.Triangulate(cells); } 

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

 Shader "Custom/VertexColors" { Properties { _Color ("Color", Color) = (1,1,1,1) _MainTex ("Albedo (RGB)", 2D) = "white" {} _Glossiness ("Smoothness", Range(0,1)) = 0.5 _Metallic ("Metallic", Range(0,1)) = 0.0 } SubShader { Tags { "RenderType"="Opaque" } LOD 200 CGPROGRAM #pragma surface surf Standard fullforwardshadows #pragma target 3.0 sampler2D _MainTex; struct Input { float2 uv_MainTex; float4 color : COLOR; }; half _Glossiness; half _Metallic; fixed4 _Color; void surf (Input IN, inout SurfaceOutputStandard o) { fixed4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color; o.Albedo = c.rgb * IN.color; o.Metallic = _Metallic; o.Smoothness = _Glossiness; o.Alpha = ca; } ENDCG } FallBack "Diffuse" } 

इस shader का उपयोग करके एक नई सामग्री बनाएँ, और फिर जाली को इस सामग्री का उपयोग करें। इसके लिए धन्यवाद, कोशिकाओं के रंग दिखाई देंगे।


रंगीन कोशिकाएँ।


unitypackage

मानचित्र संपादक

अब जब हम जानते हैं कि रंगों को कैसे बदलना है, तो आइए एक सरल इन-गेम एडिटर बनाएं। यह कार्यक्षमता क्षमताओं पर लागू नहीं होती है HexGrid, इसलिए हम इसे TouchCellअतिरिक्त रंग पैरामीटर के साथ एक सामान्य विधि में बदल देंगे । साथ ही खेत को भी हटा दें touchedColor।

 public void ColorCell (Vector3 position, Color color) { position = transform.InverseTransformPoint(position); HexCoordinates coordinates = HexCoordinates.FromPosition(position); int index = coordinates.X + coordinates.Z * width + coordinates.Z / 2; HexCell cell = cells[index]; cell.color = color; hexMesh.Triangulate(cells); } 

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

 using UnityEngine; public class HexMapEditor : MonoBehaviour { public Color[] colors; public HexGrid hexGrid; private Color activeColor; void Awake () { SelectColor(0); } void Update () { if (Input.GetMouseButton(0)) { HandleInput(); } } void HandleInput () { Ray inputRay = Camera.main.ScreenPointToRay(Input.mousePosition); RaycastHit hit; if (Physics.Raycast(inputRay, out hit)) { hexGrid.ColorCell(hit.point, activeColor); } } public void SelectColor (int index) { activeColor = colors[index]; } } 

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


चार-रंग षट्भुज मानचित्र संपादक।

रंग चयनकर्ताओं ( GameObject / UI / पैनल ) के भंडारण के लिए कैनवास में एक पैनल जोड़ें । उसे टॉगल समूह ( घटक / UI / टॉगल समूह ) जोड़ें। पैनल को छोटा करें और इसे स्क्रीन के कोने में रखें।


टॉगल समूह के साथ रंग पैनल।

अब प्रत्येक रंग के लिए स्विच के साथ पैनल भरें ( GameObject / UI / Toggle )। जब तक हम एक जटिल UI बनाने में परेशान नहीं होते हैं, तब तक सरल मैनुअल कॉन्फ़िगरेशन पर्याप्त है।



प्रत्येक रंग के लिए एक स्विच।

पहला स्विच चालू करें। टॉगल समूह के सभी स्विच भागों को भी बनाएं ताकि उनमें से केवल एक का चयन किया जा सके। अंत में, उन्हें SelectColorहमारे संपादक की विधि से जोड़ दें । यह ऑन वैल्यू चेंजेड इवेंट के "+" UI बटन का उपयोग करके किया जा सकता है । मानचित्र संपादक ऑब्जेक्ट का चयन करें, फिर ड्रॉप-डाउन सूची से वांछित विधि का चयन करें।


पहला स्विच।

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



कई रंगों में रंगना।

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

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

 using UnityEngine; using UnityEngine.EventSystems; … void Update () { if ( Input.GetMouseButton(0) && !EventSystem.current.IsPointerOverGameObject() ) { HandleInput(); } } 

unitypackage

भाग 2: सम्मिश्रण सेल रंग

सामग्री की तालिका

• पड़ोसियों को कनेक्ट करें।
• त्रिकोण के बीच के रंगों को इंटरपोल करें।
• सम्मिश्रण क्षेत्र बनाएँ।
• ज्यामिति को सरल बनाएं।

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


कोशिकाओं के बीच चिकनी संक्रमण।

पड़ोसी कोशिकाएं

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

 public enum HexDirection { NE, E, SE, SW, W, NW } 

छह पड़ोसी, छह दिशाएं।

इन पड़ोसियों को संग्रहीत करने के लिए, HexCellसरणी में जोड़ें । यद्यपि हम इसे सामान्य बना सकते हैं, हम इसके बजाय इसे निजी बना देंगे और निर्देशों का उपयोग करके तरीकों तक पहुंच प्रदान करेंगे। हम इसे सीरियल करने योग्य भी बनाते हैं ताकि बॉन्ड्स पुनःसंयोजन पर खो न जाएं।

  [SerializeField] HexCell[] neighbors; 

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


हमारे प्रीफैब में छह पड़ोसियों के लिए जगह है।

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

  public HexCell GetNeighbor (HexDirection direction) { return neighbors[(int)direction]; } 

पड़ोसी को निर्दिष्ट करने के लिए एक विधि जोड़ें।

  public void SetNeighbor (HexDirection direction, HexCell cell) { neighbors[(int)direction] = cell; } 

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

  public void SetNeighbor (HexDirection direction, HexCell cell) { neighbors[(int)direction] = cell; cell.neighbors[(int)direction.Opposite()] = this; } 

विपरीत दिशाओं में पड़ोसी।

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

 public enum HexDirection { NE, E, SE, SW, W, NW } public static class HexDirectionExtensions { public static HexDirection Opposite (this HexDirection direction) { return (int)direction < 3 ? (direction + 3) : (direction - 3); } } 

पड़ोसी कनेक्शन

हम पड़ोसियों के लिंक को इनिशियलाइज़ कर सकते हैं HexGrid.CreateCell। जब ट्रावर्सिंग सेल लाइन से लाइन में, बाएं से दाएं, हम जानते हैं कि कौन से सेल पहले से ही बनाए गए हैं। ये ऐसी कोशिकाएं हैं जिनसे हम जुड़ सकते हैं।

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


कोशिकाओं के निर्माण के दौरान ई से डब्ल्यू से कनेक्शन।

  void CreateCell (int x, int z, int i) { … cell.color = defaultColor; if (x > 0) { cell.SetNeighbor(HexDirection.W, cells[i - 1]); } Text label = Instantiate<Text>(cellLabelPrefab); … } 

पूर्वी और पश्चिमी पड़ोसी जुड़े हुए हैं।

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

  if (x > 0) { cell.SetNeighbor(HexDirection.W, cells[i - 1]); } if (z > 0) { } 

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


यहां तक ​​कि लाइनों के लिए NW से SE के लिए कनेक्शन।

  if (z > 0) { if ((z & 1) == 0) { cell.SetNeighbor(HexDirection.SE, cells[i - width]); } } 

हम SW पर पड़ोसियों के साथ जुड़ सकते हैं, प्रत्येक पंक्ति के पहले सेल को छोड़कर, जिसमें यह नहीं है।


यहां तक ​​कि लाइनों के लिए NE से SW के लिए कनेक्शन।

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

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

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

सभी पड़ोसी जुड़े हुए हैं।

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


प्रत्येक कोशिका के लिए पड़ोसी।

unitypackage

रंग मिलाना

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

  void Triangulate (HexCell cell) { for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { Triangulate(d, cell); } } void Triangulate (HexDirection direction, HexCell cell) { Vector3 center = cell.transform.localPosition; AddTriangle( center, center + HexMetrics.corners[(int)direction], center + HexMetrics.corners[(int)direction + 1] ); AddTriangleColor(cell.color); } 

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

  AddTriangle( center, center + HexMetrics.GetFirstCorner(direction), center + HexMetrics.GetSecondCorner(direction) ); 

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

  static Vector3[] corners = { new Vector3(0f, 0f, outerRadius), new Vector3(innerRadius, 0f, 0.5f * outerRadius), new Vector3(innerRadius, 0f, -0.5f * outerRadius), new Vector3(0f, 0f, -outerRadius), new Vector3(-innerRadius, 0f, -0.5f * outerRadius), new Vector3(-innerRadius, 0f, 0.5f * outerRadius), new Vector3(0f, 0f, outerRadius) }; public static Vector3 GetFirstCorner (HexDirection direction) { return corners[(int)direction]; } public static Vector3 GetSecondCorner (HexDirection direction) { return corners[(int)direction + 1]; } 

एक त्रिकोण पर कई रंग

अब तक, विधि HexMesh.AddTriangleColorमें केवल एक रंग तर्क है। यह केवल ठोस रंग के साथ एक त्रिकोण बना सकता है। आइए एक विकल्प बनाएं जो प्रत्येक शीर्ष के लिए अलग-अलग रंगों का समर्थन करता है।

  void AddTriangleColor (Color c1, Color c2, Color c3) { colors.Add(c1); colors.Add(c2); colors.Add(c3); } 

अब हम रंगों को मिलाना शुरू कर सकते हैं! चलो बस दो अन्य कोने के लिए पड़ोसी रंग का उपयोग करके शुरू करते हैं।

  void Triangulate (HexDirection direction, HexCell cell) { Vector3 center = cell.transform.localPosition; AddTriangle( center, center + HexMetrics.GetFirstCorner(direction), center + HexMetrics.GetSecondCorner(direction) ); HexCell neighbor = cell.GetNeighbor(direction); AddTriangleColor(cell.color, neighbor.color, neighbor.color); } 

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

  HexCell neighbor = cell.GetNeighbor(direction) ?? cell; 

रंगों का मिश्रण है, लेकिन यह गलत तरीके से किया जाता है।

रंग औसत

रंग मिश्रण काम करता है, लेकिन परिणाम स्पष्ट रूप से गलत हैं। हेक्सागोन्स के किनारों पर रंग दो आसन्न कोशिकाओं का औसत होना चाहिए।

  HexCell neighbor = cell.GetNeighbor(direction) ?? cell; Color edgeColor = (cell.color + neighbor.color) * 0.5f; AddTriangleColor(cell.color, edgeColor, edgeColor); 

पसलियों पर मिश्रण।
यद्यपि हम किनारों पर मिश्रण कर रहे हैं, फिर भी हमें तेज रंग की सीमाएँ मिलती हैं। ऐसा इसलिए होता है क्योंकि षट्भुज के प्रत्येक शीर्ष को तीन षट्कोणों द्वारा साझा किया जाता है।


तीन पड़ोसी, चार रंग।

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

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

  public static HexDirection Previous (this HexDirection direction) { return direction == HexDirection.NE ? HexDirection.NW : (direction - 1); } public static HexDirection Next (this HexDirection direction) { return direction == HexDirection.NW ? HexDirection.NE : (direction + 1); } 

अब हम सभी तीन पड़ोसियों को प्राप्त कर सकते हैं और तीन-तरफा मिश्रण कर सकते हैं।

  HexCell prevNeighbor = cell.GetNeighbor(direction.Previous()) ?? cell; HexCell neighbor = cell.GetNeighbor(direction) ?? cell; HexCell nextNeighbor = cell.GetNeighbor(direction.Next()) ?? cell; AddTriangleColor( cell.color, (cell.color + prevNeighbor.color + neighbor.color) / 3f, (cell.color + neighbor.color + nextNeighbor.color) / 3f ); 

कोनों पर मिलाएं।

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

unitypackage

मिश्रण का क्षेत्र

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


मिश्रण क्षेत्रों के साथ सेंट की निरंतर छायांकन।

मिश्रण क्षेत्र की तुलना में ठोस क्षेत्र का आकार क्या होना चाहिए? अलग-अलग वितरण अलग-अलग परिणाम देते हैं। हम इस क्षेत्र को बाहरी दायरे के एक अंश के रूप में परिभाषित करेंगे। इसे 75% के बराबर करें। यह हमें दो नए मैट्रिक्स की ओर ले जाएगा, कुल 100%।

  public const float solidFactor = 0.75f; public const float blendFactor = 1f - solidFactor; 

इस नए ठोस भरण कारक को बनाकर, हम ठोस आंतरिक षट्भुज के कोण प्राप्त करने के लिए तरीके लिख सकते हैं।

  public static Vector3 GetFirstSolidCorner (HexDirection direction) { return corners[(int)direction] * solidFactor; } public static Vector3 GetSecondSolidCorner (HexDirection direction) { return corners[(int)direction + 1] * solidFactor; } 

अब, HexMesh.Triangulateइसे बदल दें ताकि यह मूल कोणों के बजाय इन ठोस छायांकन कोणों का उपयोग करे। हम अभी के लिए रंगों को छोड़ देते हैं।

  AddTriangle( center, center + HexMetrics.GetFirstSolidCorner(direction), center + HexMetrics.GetSecondSolidCorner(direction) ); 

किनारों के बिना ठोस हेक्सागोन्स।

मिश्रण क्षेत्रों का त्रिकोणासन

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


ट्रेपेज़ॉइड रिब।

  void AddQuad (Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4) { int vertexIndex = vertices.Count; vertices.Add(v1); vertices.Add(v2); vertices.Add(v3); vertices.Add(v4); triangles.Add(vertexIndex); triangles.Add(vertexIndex + 2); triangles.Add(vertexIndex + 1); triangles.Add(vertexIndex + 1); triangles.Add(vertexIndex + 2); triangles.Add(vertexIndex + 3); } void AddQuadColor (Color c1, Color c2, Color c3, Color c4) { colors.Add(c1); colors.Add(c2); colors.Add(c3); colors.Add(c4); } 

हम HexMesh.Triangulateइसे रीमेक करते हैं ताकि त्रिकोण एक रंग प्राप्त करता है, और चतुर्भुज एक ठोस रंग और दो कोणों के रंगों के बीच मिश्रण करता है।

  void Triangulate (HexDirection direction, HexCell cell) { Vector3 center = cell.transform.localPosition; Vector3 v1 = center + HexMetrics.GetFirstSolidCorner(direction); Vector3 v2 = center + HexMetrics.GetSecondSolidCorner(direction); AddTriangle(center, v1, v2); AddTriangleColor(cell.color); Vector3 v3 = center + HexMetrics.GetFirstCorner(direction); Vector3 v4 = center + HexMetrics.GetSecondCorner(direction); AddQuad(v1, v2, v3, v4); HexCell prevNeighbor = cell.GetNeighbor(direction.Previous()) ?? cell; HexCell neighbor = cell.GetNeighbor(direction) ?? cell; HexCell nextNeighbor = cell.GetNeighbor(direction.Next()) ?? cell; AddQuadColor( cell.color, cell.color, (cell.color + prevNeighbor.color + neighbor.color) / 3f, (cell.color + neighbor.color + nextNeighbor.color) / 3f ); } 

ट्रेपेज़ॉइड पसलियों के साथ मिश्रण।

पसलियों के बीच का पुल

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


पसलियों के बीच का पुल।

हम नए पदों पा सकते हैं v3और v4, के साथ शुरू v1और v2उसके बाद सेल किनारे करने के लिए सीधे पुल के किनारे ले जाया गया। पुल का विस्थापन क्या होगा? हम इसे दो संबंधित कोणों के बीच के मध्य बिंदु पर ले जा सकते हैं, और फिर इसमें मिश्रण गुणांक लागू कर सकते हैं। यह करेंगे HexMetrics।

  public static Vector3 GetBridge (HexDirection direction) { return (corners[(int)direction] + corners[(int)direction + 1]) * 0.5f * blendFactor; } 

वापस HexMesh, अब एक विकल्प जोड़ना तर्कसंगत होगा AddQuadColorजिसमें केवल दो रंगों की आवश्यकता होती है।

  void AddQuadColor (Color c1, Color c2) { colors.Add(c1); colors.Add(c1); colors.Add(c2); colors.Add(c2); } 

इसे बदलें Triangulateताकि यह पड़ोसियों के बीच ठीक से मिश्रित पुलों का निर्माण करे।

  Vector3 bridge = HexMetrics.GetBridge(direction); Vector3 v3 = v1 + bridge; Vector3 v4 = v2 + bridge; AddQuad(v1, v2, v3, v4); HexCell prevNeighbor = cell.GetNeighbor(direction.Previous()) ?? cell; HexCell neighbor = cell.GetNeighbor(direction) ?? cell; HexCell nextNeighbor = cell.GetNeighbor(direction.Next()) ?? cell; AddQuadColor(cell.color, (cell.color + neighbor.color) * 0.5f); 

कोने के स्थानों के साथ सही ढंग से चित्रित पुल।

अंतराल में भरना

अब हमने तीन कोशिकाओं के जंक्शन पर एक त्रिकोणीय अंतर बनाया है। ट्रेपेज़ॉइड के त्रिकोणीय पक्षों को काटकर हमें ये अंतराल मिले। आइए इन त्रिकोणों को वापस लाएं।

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

  Color bridgeColor = (cell.color + neighbor.color) * 0.5f; AddQuadColor(cell.color, bridgeColor); AddTriangle(v1, center + HexMetrics.GetFirstCorner(direction), v3); AddTriangleColor( cell.color, (cell.color + prevNeighbor.color + neighbor.color) / 3f, bridgeColor ); 

लगभग सब कुछ तैयार है।

एक और त्रिकोण उसी तरह से काम करता है, सिवाय इसके कि पुल तीसरे को नहीं छूता है, लेकिन दूसरा शिखर।

  AddTriangle(v2, v4, center + HexMetrics.GetSecondCorner(direction)); AddTriangleColor( cell.color, bridgeColor, (cell.color + neighbor.color + nextNeighbor.color) / 3f ); 

पूर्ण रंग।

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


unitypackage

रिब फ्यूजन

हमारे ग्रिड की टोपोलॉजी पर एक नज़र डालें। यहां कौन से रूप ध्यान देने योग्य हैं? यदि आप सीमा पर ध्यान नहीं देते हैं, तो हम तीन अलग-अलग प्रकार के रूपों को भेद सकते हैं। एक रंग के हेक्सागोन्स, दो-रंग के आयताकार और तीन-रंग के त्रिकोण हैं। ये तीनों रंग तीनों कोशिकाओं के जंक्शन पर दिखाई देते हैं।


तीन दृश्य संरचनाएँ।

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


आवश्यकता से अधिक कठोर।

प्रत्यक्ष ब्रिजिंग

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

  public static Vector3 GetBridge (HexDirection direction) { return (corners[(int)direction] + corners[(int)direction + 1]) * blendFactor; } 

पुलों ने पूरी लंबाई को फैलाया और एक दूसरे को ओवरलैप किया।

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

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

  void Triangulate (HexDirection direction, HexCell cell) { Vector3 center = cell.transform.localPosition; Vector3 v1 = center + HexMetrics.GetFirstSolidCorner(direction); Vector3 v2 = center + HexMetrics.GetSecondSolidCorner(direction); AddTriangle(center, v1, v2); AddTriangleColor(cell.color); TriangulateConnection(direction, cell, v1, v2); } void TriangulateConnection ( HexDirection direction, HexCell cell, Vector3 v1, Vector3 v2 ) { HexCell neighbor = cell.GetNeighbor(direction) ?? cell; Vector3 bridge = HexMetrics.GetBridge(direction); Vector3 v3 = v1 + bridge; Vector3 v4 = v2 + bridge; AddQuad(v1, v2, v3, v4); AddQuadColor(cell.color, neighbor.color); } 

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

  if (direction == HexDirection.NE) { TriangulateConnection(direction, cell, v1, v2); } 

ब्रिज केवल एनई की दिशा में हैं।

ऐसा लगता है कि हम सभी यौगिकों को केवल पहले तीन दिशाओं में त्रिभुज द्वारा कवर कर सकते हैं: एनई, ई और एसई।

  if (direction <= HexDirection.SE) { TriangulateConnection(direction, cell, v1, v2); } 

सभी आंतरिक पुलों और सीमाओं पर पुल।

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

  void TriangulateConnection ( HexDirection direction, HexCell cell, Vector3 v1, Vector3 v2 ) { HexCell neighbor = cell.GetNeighbor(direction); if (neighbor == null) { return; } … } 

केवल आंतरिक पुल।

त्रिकोणीय जोड़ों

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

  void TriangulateConnection ( HexDirection direction, HexCell cell, Vector3 v1, Vector3 v2 ) { … HexCell nextNeighbor = cell.GetNeighbor(direction.Next()); if (nextNeighbor != null) { AddTriangle(v2, v4, v2); AddTriangleColor(cell.color, neighbor.color, nextNeighbor.color); } } 

तीसरी चोटी की स्थिति क्या होगी? मैंने प्रतिस्थापन के रूप में डाला v2, लेकिन यह स्पष्ट रूप से गलत है। चूंकि इन त्रिकोणों में से प्रत्येक किनारे पुल से जुड़ा हुआ है, इसलिए हम पुल के साथ अगले पड़ोसी के पास जाकर इसे पा सकते हैं।

  AddTriangle(v2, v4, v2 + HexMetrics.GetBridge(direction.Next())); 

हम फिर से पूरी कोशिश कर रहे हैं।

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

  if (direction <= HexDirection.E && nextNeighbor != null) { AddTriangle(v2, v4, v2 + HexMetrics.GetBridge(direction.Next())); AddTriangleColor(cell.color, neighbor.color, nextNeighbor.color); } 

unitypackage

भाग 3: ऊँचाई

सामग्री की तालिका

• कोशिकाओं की ऊँचाई जोड़ें।
• ढलानों को त्रिकोणित करें।
• लीड्स डालें।
• लीड और क्लिफ को मिलाएं।

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


ऊँचाई और अगुवाई।

सेल ऊंचाई

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

  public int elevation; 

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

  public const float elevationStep = 5f; 

कोशिकाओं को बदलें

अब तक, हम केवल सेल का रंग बदल सकते थे, लेकिन अब हम इसकी ऊंचाई बदल सकते हैं। इसलिए, विधि HexGrid.ColorCellहमारे लिए पर्याप्त नहीं है। इसके अलावा, भविष्य में, हम अन्य सेल संपादन विकल्प जोड़ सकते हैं, इसलिए हमें एक नया दृष्टिकोण चाहिए।

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

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

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

  public void Refresh () { hexMesh.Triangulate(cells); } 

बदलो HexMapEditorताकि वह नए तरीकों के साथ काम कर सके। आइए उसे एक नया तरीका दें EditCell, जो सेल के सभी परिवर्तनों से निपटेगा, जिसके बाद यह ग्रिड को अपडेट करेगा।

  void HandleInput () { Ray inputRay = Camera.main.ScreenPointToRay(Input.mousePosition); RaycastHit hit; if (Physics.Raycast(inputRay, out hit)) { EditCell(hexGrid.GetCell(hit.point)); } } void EditCell (HexCell cell) { cell.color = activeColor; hexGrid.Refresh(); } 

हम वांछित सेल को वांछित ऊंचाई स्तर बताकर ऊंचाइयों को बदल सकते हैं।

  int activeElevation; void EditCell (HexCell cell) { cell.color = activeColor; cell.elevation = activeElevation; hexGrid.Refresh(); } 

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

  public void SetElevation (float elevation) { activeElevation = (int)elevation; } 

कैनवास पर एक स्लाइडर ( GameObject / Create / Slider ) जोड़ें और इसे कलर बार के नीचे रखें। हम इसे ऊर्ध्वाधर बनाते हैं, नीचे से ऊपर तक, ताकि नेत्रहीन यह ऊंचाइयों के स्तर से मेल खाता हो। हम इसे पूर्णांक तक सीमित करते हैं और एक उपयुक्त अंतराल बनाते हैं, उदाहरण के लिए, 0 से 6 तक। तब हम इसकी ऑन चेंज घटना को हेक्स मैप एडिटरSetElevation ऑब्जेक्ट विधि से जोड़ते हैं । विधि को डायनामिक सूची से चुना जाना चाहिए ताकि इसे स्लाइडर के मूल्य के साथ कहा जाए।



ऊँचाई का स्लाइडर।

ऊँचाई का दृश्य

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

यह हमारे लिए ऊंचाई को बदलते समय सेल की ऊर्ध्वाधर स्थानीय स्थिति को बदलने के लिए पर्याप्त है। सुविधा के लिए, आइए विधि को HexCell.elevationनिजी बनाएं और एक सामान्य संपत्ति जोड़ें HexCell.Elevation।

  public int Elevation { get { return elevation; } set { elevation = value; } } int elevation; 

अब हम ऊंचाई को संपादित करते समय सेल की ऊर्ध्वाधर स्थिति को बदल सकते हैं।

  set { elevation = value; Vector3 position = transform.localPosition; position.y = value * HexMetrics.elevationStep; transform.localPosition = position; } 

बेशक, इसके लिए छोटे बदलावों की आवश्यकता है HexMapEditor.EditCell।

  void EditCell (HexCell cell) { cell.color = activeColor; cell.Elevation = activeElevation; hexGrid.Refresh(); } 

विभिन्न ऊंचाइयों वाले सेल।


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

सेल लेबल की स्थिति बदलें

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

  public RectTransform uiRect; 

उन्हें अंत में असाइन करें HexGrid.CreateCell।

  void CreateCell (int x, int z, int i) { … cell.uiRect = label.rectTransform; } 

अब हम संपत्ति का विस्तार कर सकते हैं HexCell.Elevationताकि यह सेल के UI की स्थिति को भी बदल दे। चूंकि हेक्सागोन्स के कैनवास जाल को घुमाया जाता है, इसलिए लेबल को Z अक्ष के साथ नकारात्मक दिशा में ले जाना चाहिए, और Y अक्ष के सकारात्मक पक्ष में नहीं।

  set { elevation = value; Vector3 position = transform.localPosition; position.y = value * HexMetrics.elevationStep; transform.localPosition = position; Vector3 uiPosition = uiRect.localPosition; uiPosition.z = elevation * -HexMetrics.elevationStep; uiRect.localPosition = uiPosition; } 

टैग ऊंचाई के साथ।

ढलान का निर्माण

अब हमें फ्लैट सेल कनेक्शन को ढलान में बदलने की आवश्यकता है। इसमें किया जाता है HexMesh.TriangulateConnection। किनारे के कनेक्शन के मामले में, हमें पुल के दूसरे छोर की ऊंचाई को फिर से परिभाषित करने की आवश्यकता है।

  Vector3 bridge = HexMetrics.GetBridge(direction); Vector3 v3 = v1 + bridge; Vector3 v4 = v2 + bridge; v3.y = v4.y = neighbor.Elevation * HexMetrics.elevationStep; 

कोने के जोड़ों के मामले में, हमें अगले पड़ोसी को पुल के साथ ऐसा करने की आवश्यकता है।

  if (direction <= HexDirection.E && nextNeighbor != null) { Vector3 v5 = v2 + HexMetrics.GetBridge(direction.Next()); v5.y = nextNeighbor.Elevation * HexMetrics.elevationStep; AddTriangle(v2, v4, v5); AddTriangleColor(cell.color, neighbor.color, nextNeighbor.color); } 

खाता ऊंचाई में ले जा रहा कनेक्शन।

अब हमारे पास अलग-अलग ऊंचाइयों पर कोशिकाओं के लिए समर्थन है जो उनके बीच सही झुकाव वाले जोड़ों के साथ हैं। लेकिन चलो वहाँ नहीं रुकते। हम इन ढलानों को और अधिक रोचक बनाएंगे।

unitypackage

अग्न्याशय के साथ रिब जोड़ों

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

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


ढलान पर दो अगुवाई।

हम ढलान के लिए चरणों की संख्या निर्धारित कर सकते हैं HexMetricsऔर इसके आधार पर चरणों की संख्या की गणना कर सकते हैं।

  public const int terracesPerSlope = 2; public const int terraceSteps = terracesPerSlope * 2 + 1; 

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

  public static Vector3 TerraceLerp (Vector3 a, Vector3 b, int step) { return a; } 

क्षैतिज प्रक्षेप सरल है अगर हम प्रक्षेप कदम के आकार को जानते हैं।

  public const float horizontalTerraceStepSize = 1f / terraceSteps; public static Vector3 TerraceLerp (Vector3 a, Vector3 b, int step) { float h = step * HexMetrics.horizontalTerraceStepSize; ax += (bx - ax) * h; az += (bz - az) * h; return a; } 

केवल विषम चरणों में वाई को बदलने के लिए, हम उपयोग कर सकते हैं $$$(step + 1) / 2$ । यदि हम पूर्णांक विभाजन का उपयोग करते हैं, तो यह श्रृंखला 1, 2, 3, 4 को 1, 1, 2, 2 में बदल देगा।

  public const float verticalTerraceStepSize = 1f / (terracesPerSlope + 1); public static Vector3 TerraceLerp (Vector3 a, Vector3 b, int step) { float h = step * HexMetrics.horizontalTerraceStepSize; ax += (bx - ax) * h; az += (bz - az) * h; float v = ((step + 1) / 2) * HexMetrics.verticalTerraceStepSize; ay += (by - ay) * v; return a; } 

आइए रंगों के साथ-साथ रंगों को प्रक्षेपित करने के लिए एक विधि जोड़ें। बस उन्हें प्रक्षेपित करें जैसे कि कनेक्शन फ्लैट हैं।

  public static Color TerraceLerp (Color a, Color b, int step) { float h = step * HexMetrics.horizontalTerraceStepSize; return Color.Lerp(a, b, h); } 

ट्राईऐन्ग्युलेशंस

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

  void TriangulateConnection ( HexDirection direction, HexCell cell, Vector3 v1, Vector3 v2 ) { … Vector3 bridge = HexMetrics.GetBridge(direction); Vector3 v3 = v1 + bridge; Vector3 v4 = v2 + bridge; v3.y = v4.y = neighbor.Elevation * HexMetrics.elevationStep; TriangulateEdgeTerraces(v1, v2, cell, v3, v4, neighbor); // AddQuad(v1, v2, v3, v4); // AddQuadColor(cell.color, neighbor.color); … } void TriangulateEdgeTerraces ( Vector3 beginLeft, Vector3 beginRight, HexCell beginCell, Vector3 endLeft, Vector3 endRight, HexCell endCell ) { AddQuad(beginLeft, beginRight, endLeft, endRight); AddQuadColor(beginCell.color, endCell.color); } 

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

  void TriangulateEdgeTerraces ( Vector3 beginLeft, Vector3 beginRight, HexCell beginCell, Vector3 endLeft, Vector3 endRight, HexCell endCell ) { Vector3 v3 = HexMetrics.TerraceLerp(beginLeft, endLeft, 1); Vector3 v4 = HexMetrics.TerraceLerp(beginRight, endRight, 1); Color c2 = HexMetrics.TerraceLerp(beginCell.color, endCell.color, 1); AddQuad(beginLeft, beginRight, v3, v4); AddQuadColor(beginCell.color, c2); } 

एक पहला कदम बनाने में।

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

  AddQuad(beginLeft, beginRight, v3, v4); AddQuadColor(beginCell.color, c2); AddQuad(v3, v4, endLeft, endRight); AddQuadColor(c2, endCell.color); 

एक कगार बनाने में अंतिम चरण।

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

  AddQuad(beginLeft, beginRight, v3, v4); AddQuadColor(beginCell.color, c2); for (int i = 2; i < HexMetrics.terraceSteps; i++) { Vector3 v1 = v3; Vector3 v2 = v4; Color c1 = c2; v3 = HexMetrics.TerraceLerp(beginLeft, endLeft, i); v4 = HexMetrics.TerraceLerp(beginRight, endRight, i); c2 = HexMetrics.TerraceLerp(beginCell.color, endCell.color, i); AddQuad(v1, v2, v3, v4); AddQuadColor(c1, c2); } AddQuad(v3, v4, endLeft, endRight); AddQuadColor(c2, endCell.color); 

सभी मध्यवर्ती चरण।

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


किनारों के सभी जोड़ों में अगुवाई होती है।

unitypackage

कनेक्शन प्रकार

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

आइए इसे औपचारिक रूप दें और तीन प्रकार के किनारों को परिभाषित करें: एक विमान, एक ढलान और एक चट्टान। आइए इसके लिए एक संकल्‍प बनाएं।

 public enum HexEdgeType { Flat, Slope, Cliff } 

यह कैसे निर्धारित किया जाए कि हम किस प्रकार के कनेक्शन के साथ काम कर रहे हैं? ऐसा करने के लिए, हम एक ऐसी HexMetricsविधि में जोड़ सकते हैं जो ऊंचाई के दो स्तरों का उपयोग करती है।

  public static HexEdgeType GetEdgeType (int elevation1, int elevation2) { } 

यदि ऊंचाइयां समान हैं, तो हमारे पास एक सपाट रिब होगा।

  public static HexEdgeType GetEdgeType (int elevation1, int elevation2) { if (elevation1 == elevation2) { return HexEdgeType.Flat; } } 

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

  public static HexEdgeType GetEdgeType (int elevation1, int elevation2) { if (elevation1 == elevation2) { return HexEdgeType.Flat; } int delta = elevation2 - elevation1; if (delta == 1 || delta == -1) { return HexEdgeType.Slope; } return HexEdgeType.Cliff; } 

चलो HexCell.GetEdgeTypeएक निश्चित दिशा में सेल बढ़त के प्रकार को प्राप्त करने के लिए एक सुविधाजनक विधि भी जोड़ते हैं ।

  public HexEdgeType GetEdgeType (HexDirection direction) { return HexMetrics.GetEdgeType( elevation, neighbors[(int)direction].elevation ); } 

केवल ढलान के लिए ledges बनाएँ

अब जब हम कनेक्शन के प्रकार को निर्धारित कर सकते हैं, तो हम यह तय कर सकते हैं कि क्या सम्मिलित करना है। बदलो HexMesh.TriangulateConnectionताकि वह केवल ढलान के लिए ledges बनाता है।

  if (cell.GetEdgeType(direction) == HexEdgeType.Slope) { TriangulateEdgeTerraces(v1, v2, cell, v3, v4, neighbor); } // AddQuad(v1, v2, v3, v4); // AddQuadColor(cell.color, neighbor.color); 

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

  if (cell.GetEdgeType(direction) == HexEdgeType.Slope) { TriangulateEdgeTerraces(v1, v2, cell, v3, v4, neighbor); } else { AddQuad(v1, v2, v3, v4); AddQuadColor(cell.color, neighbor.color); } 

कदम ढलान पर ही बनाए जाते हैं।

unitypackage

नेतृत्व के साथ नेतृत्व

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

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


कोना संयुक्त।

  void TriangulateCorner ( Vector3 bottom, HexCell bottomCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { AddTriangle(bottom, left, right); AddTriangleColor(bottomCell.color, leftCell.color, rightCell.color); } 

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

  void TriangulateConnection ( HexDirection direction, HexCell cell, Vector3 v1, Vector3 v2 ) { … HexCell nextNeighbor = cell.GetNeighbor(direction.Next()); if (direction <= HexDirection.E && nextNeighbor != null) { Vector3 v5 = v2 + HexMetrics.GetBridge(direction.Next()); v5.y = nextNeighbor.Elevation * HexMetrics.elevationStep; if (cell.Elevation <= neighbor.Elevation) { if (cell.Elevation <= nextNeighbor.Elevation) { TriangulateCorner(v2, cell, v4, neighbor, v5, nextNeighbor); } } } } 

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

  if (cell.Elevation <= neighbor.Elevation) { if (cell.Elevation <= nextNeighbor.Elevation) { TriangulateCorner(v2, cell, v4, neighbor, v5, nextNeighbor); } else { TriangulateCorner(v5, nextNeighbor, v2, cell, v4, neighbor); } } 

यदि पहला परीक्षण विफल हो जाता है, तो आपको दो पड़ोसी कोशिकाओं की तुलना करने की आवश्यकता है। यदि पसली का पड़ोसी सबसे कम है, तो आपको घड़ी की दिशा में मुड़ने की आवश्यकता है, अन्यथा - वामावर्त।

  if (cell.Elevation <= neighbor.Elevation) { if (cell.Elevation <= nextNeighbor.Elevation) { TriangulateCorner(v2, cell, v4, neighbor, v5, nextNeighbor); } else { TriangulateCorner(v5, nextNeighbor, v2, cell, v4, neighbor); } } else if (neighbor.Elevation <= nextNeighbor.Elevation) { TriangulateCorner(v4, neighbor, v5, nextNeighbor, v2, cell); } else { TriangulateCorner(v5, nextNeighbor, v2, cell, v4, neighbor); } 

वामावर्त मुड़ें, कोई मोड़ नहीं, दक्षिणावर्त घुमाव।

ढलान त्रिकोण

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

  public HexEdgeType GetEdgeType (HexCell otherCell) { return HexMetrics.GetEdgeType( elevation, otherCell.elevation ); } 

HexMesh.TriangulateCornerबाएं और दाएं किनारों के प्रकारों को निर्धारित करने के लिए हम इस नई विधि का उपयोग करते हैं ।

  void TriangulateCorner ( Vector3 bottom, HexCell bottomCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { HexEdgeType leftEdgeType = bottomCell.GetEdgeType(leftCell); HexEdgeType rightEdgeType = bottomCell.GetEdgeType(rightCell); AddTriangle(bottom, left, right); AddTriangleColor(bottomCell.color, leftCell.color, rightCell.color); } 

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


दो ढलान और एक विमान, एसएसपी।

हम जांच करेंगे कि क्या हम इस स्थिति में हैं, और यदि ऐसा है, तो हम एक नई विधि कहेंगे TriangulateCornerTerraces। उसके बाद, हम विधि से वापस आ जाएंगे। इस जाँच को पुराने त्रिभुज कोड से पहले डालें ताकि यह मूल त्रिभुज को बदल दे।

  void TriangulateCorner ( Vector3 bottom, HexCell bottomCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { HexEdgeType leftEdgeType = bottomCell.GetEdgeType(leftCell); HexEdgeType rightEdgeType = bottomCell.GetEdgeType(rightCell); if (leftEdgeType == HexEdgeType.Slope) { if (rightEdgeType == HexEdgeType.Slope) { TriangulateCornerTerraces( bottom, bottomCell, left, leftCell, right, rightCell ); return; } } AddTriangle(bottom, left, right); AddTriangleColor(bottomCell.color, leftCell.color, rightCell.color); } void TriangulateCornerTerraces ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { } 

चूंकि हम अंदर कुछ नहीं कर रहे हैं TriangulateCornerTerraces, दो ढलान के साथ कुछ कोने जंक्शनों voids हो जाएंगे। क्या कनेक्शन खाली हो जाता है या नहीं यह इस बात पर निर्भर करता है कि कौन सी सेल कम है।


एक शून्य है।

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

  void TriangulateCornerTerraces ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { Vector3 v3 = HexMetrics.TerraceLerp(begin, left, 1); Vector3 v4 = HexMetrics.TerraceLerp(begin, right, 1); Color c3 = HexMetrics.TerraceLerp(beginCell.color, leftCell.color, 1); Color c4 = HexMetrics.TerraceLerp(beginCell.color, rightCell.color, 1); AddTriangle(begin, v3, v4); AddTriangleColor(beginCell.color, c3, c4); } 

त्रिभुज का पहला चरण।

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

  AddTriangle(begin, v3, v4); AddTriangleColor(beginCell.color, c3, c4); AddQuad(v3, v4, left, right); AddQuadColor(c3, c4, leftCell.color, rightCell.color); 

चतुष्कोण का अंतिम चरण।

उनके बीच के सभी चरण भी चतुष्कोणीय हैं।

  AddTriangle(begin, v3, v4); AddTriangleColor(beginCell.color, c3, c4); for (int i = 2; i < HexMetrics.terraceSteps; i++) { Vector3 v1 = v3; Vector3 v2 = v4; Color c1 = c3; Color c2 = c4; v3 = HexMetrics.TerraceLerp(begin, left, i); v4 = HexMetrics.TerraceLerp(begin, right, i); c3 = HexMetrics.TerraceLerp(beginCell.color, leftCell.color, i); c4 = HexMetrics.TerraceLerp(beginCell.color, rightCell.color, i); AddQuad(v1, v2, v3, v4); AddQuadColor(c1, c2, c3, c4); } AddQuad(v3, v4, left, right); AddQuadColor(c3, c4, leftCell.color, rightCell.color); 

सभी चरणों।

दो ढलान विविधताएं

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


एटीपी और एमएसएस।

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

  if (leftEdgeType == HexEdgeType.Slope) { if (rightEdgeType == HexEdgeType.Slope) { TriangulateCornerTerraces( bottom, bottomCell, left, leftCell, right, rightCell ); return; } if (rightEdgeType == HexEdgeType.Flat) { TriangulateCornerTerraces( left, leftCell, right, rightCell, bottom, bottomCell ); return; } } if (rightEdgeType == HexEdgeType.Slope) { if (leftEdgeType == HexEdgeType.Flat) { TriangulateCornerTerraces( right, rightCell, bottom, bottomCell, left, leftCell ); return; } } 

इसके कारण, प्रकोष्ठ बिना किसी रुकावट के कोशिकाओं के चारों ओर जाएंगे जब तक वे चट्टान या मानचित्र के अंत तक नहीं पहुंच जाते।


ठोस अगुवाई।

unitypackage

ढलान और चट्टानों का विलय

ढलान और चट्टान को जोड़ने के बारे में क्या? यदि हम जानते हैं कि बायाँ छोर एक ढलान है और दायाँ किनारा चट्टान है, तो ऊपरी किनारा क्या होगा? यह समतल नहीं हो सकता है, लेकिन यह ढलान या चट्टान हो सकता है।




एसओएस और सीओओ।

सभी ढलान-क्लिफ मामलों को संभालने के लिए एक नई विधि जोड़ें।

  void TriangulateCornerTerracesCliff ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { } 

यह आखिरी विकल्प के रूप में कहा जाना चाहिए TriangulateCornerजब बाएं किनारे एक ढलान है।

  if (leftEdgeType == HexEdgeType.Slope) { if (rightEdgeType == HexEdgeType.Slope) { TriangulateCornerTerraces( bottom, bottomCell, left, leftCell, right, rightCell ); return; } if (rightEdgeType == HexEdgeType.Flat) { TriangulateCornerTerraces( left, leftCell, right, rightCell, bottom, bottomCell ); return; } TriangulateCornerTerracesCliff( bottom, bottomCell, left, leftCell, right, rightCell ); return; } if (rightEdgeType == HexEdgeType.Slope) { if (leftEdgeType == HexEdgeType.Flat) { TriangulateCornerTerraces( right, rightCell, bottom, bottomCell, left, leftCell ); return; } } 

हम इसे कैसे टाँगेंगे? इस कार्य को दो भागों में विभाजित किया जा सकता है: निचला और ऊपरी।

निचला हिस्सा

निचले हिस्से में बाईं तरफ और दाईं ओर एक चट्टान है। हमें किसी तरह उन्हें संयोजित करने की आवश्यकता है। ऐसा करने का सबसे आसान तरीका है कि निचोड़ को निचोड़कर ताकि वे सही कोने में मिलें। यह उभार को बढ़ाएगा।


कगार का संपीड़न।

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


सीमा पर संपीड़न।

आइए नीचे के सेल के ऊपर सीमा बिंदु को एक स्तर पर रखें। आप इसे ऊंचाई अंतर के आधार पर प्रक्षेप द्वारा पा सकते हैं।

  void TriangulateCornerTerracesCliff ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { float b = 1f / (rightCell.Elevation - beginCell.Elevation); Vector3 boundary = Vector3.Lerp(begin, right, b); Color boundaryColor = Color.Lerp(beginCell.color, rightCell.color, b); } 

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

  float b = 1f / (rightCell.Elevation - beginCell.Elevation); Vector3 boundary = Vector3.Lerp(begin, right, b); Color boundaryColor = Color.Lerp(beginCell.color, rightCell.color, b); AddTriangle(begin, left, boundary); AddTriangleColor(beginCell.color, leftCell.color, boundaryColor); 

नीचे का त्रिकोण।

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

  float b = 1f / (rightCell.Elevation - beginCell.Elevation); Vector3 boundary = Vector3.Lerp(begin, right, b); Color boundaryColor = Color.Lerp(beginCell.color, rightCell.color, b); Vector3 v2 = HexMetrics.TerraceLerp(begin, left, 1); Color c2 = HexMetrics.TerraceLerp(beginCell.color, leftCell.color, 1); AddTriangle(begin, v2, boundary); AddTriangleColor(beginCell.color, c2, boundaryColor); 

संपीड़न का पहला चरण।

इस बार, अंतिम चरण भी एक त्रिकोण होगा।

  AddTriangle(begin, v2, boundary); AddTriangleColor(beginCell.color, c2, boundaryColor); AddTriangle(v2, left, boundary); AddTriangleColor(c2, leftCell.color, boundaryColor); 

संपीड़न का अंतिम चरण।

और सभी मध्यवर्ती चरण भी त्रिकोण हैं।

  AddTriangle(begin, v2, boundary); AddTriangleColor(beginCell.color, c2, boundaryColor); for (int i = 2; i < HexMetrics.terraceSteps; i++) { Vector3 v1 = v2; Color c1 = c2; v2 = HexMetrics.TerraceLerp(begin, left, i); c2 = HexMetrics.TerraceLerp(beginCell.color, leftCell.color, i); AddTriangle(v1, v2, boundary); AddTriangleColor(c1, c2, boundaryColor); } AddTriangle(v2, left, boundary); AddTriangleColor(c2, leftCell.color, boundaryColor); 

संकुचित नेतृत्व।

कोना पूरा होना

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

  void TriangulateCornerTerracesCliff ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { float b = 1f / (rightCell.Elevation - beginCell.Elevation); Vector3 boundary = Vector3.Lerp(begin, right, b); Color boundaryColor = Color.Lerp(beginCell.color, rightCell.color, b); TriangulateBoundaryTriangle( begin, beginCell, left, leftCell, boundary, boundaryColor ); } void TriangulateBoundaryTriangle ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 boundary, Color boundaryColor ) { Vector3 v2 = HexMetrics.TerraceLerp(begin, left, 1); Color c2 = HexMetrics.TerraceLerp(beginCell.color, leftCell.color, 1); AddTriangle(begin, v2, boundary); AddTriangleColor(beginCell.color, c2, boundaryColor); for (int i = 2; i < HexMetrics.terraceSteps; i++) { Vector3 v1 = v2; Color c1 = c2; v2 = HexMetrics.TerraceLerp(begin, left, i); c2 = HexMetrics.TerraceLerp(beginCell.color, leftCell.color, i); AddTriangle(v1, v2, boundary); AddTriangleColor(c1, c2, boundaryColor); } AddTriangle(v2, left, boundary); AddTriangleColor(c2, leftCell.color, boundaryColor); } 

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

  void TriangulateCornerTerracesCliff ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { float b = 1f / (rightCell.Elevation - beginCell.Elevation); Vector3 boundary = Vector3.Lerp(begin, right, b); Color boundaryColor = Color.Lerp(beginCell.color, rightCell.color, b); TriangulateBoundaryTriangle( begin, beginCell, left, leftCell, boundary, boundaryColor ); if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope) { TriangulateBoundaryTriangle( left, leftCell, right, rightCell, boundary, boundaryColor ); } else { AddTriangle(left, right, boundary); AddTriangleColor(leftCell.color, rightCell.color, boundaryColor); } } 

दोनों भागों का पूरा त्रिभुज।

प्रतिबिंबित मामले

हमने "ढलान-चट्टान" के मामलों की जांच की। दो दर्पण मामले भी हैं, जिनमें से प्रत्येक में बाईं ओर एक चट्टान है।


OSS और CCA।

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

  void TriangulateCornerCliffTerraces ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { float b = 1f / (leftCell.Elevation - beginCell.Elevation); Vector3 boundary = Vector3.Lerp(begin, left, b); Color boundaryColor = Color.Lerp(beginCell.color, leftCell.color, b); TriangulateBoundaryTriangle( right, rightCell, begin, beginCell, boundary, boundaryColor ); if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope) { TriangulateBoundaryTriangle( left, leftCell, right, rightCell, boundary, boundaryColor ); } else { AddTriangle(left, right, boundary); AddTriangleColor(leftCell.color, rightCell.color, boundaryColor); } } 

इन मामलों को जोड़ें TriangulateCorner।

  if (leftEdgeType == HexEdgeType.Slope) { … } if (rightEdgeType == HexEdgeType.Slope) { if (leftEdgeType == HexEdgeType.Flat) { TriangulateCornerTerraces( right, rightCell, bottom, bottomCell, left, leftCell ); return; } TriangulateCornerCliffTerraces( bottom, bottomCell, left, leftCell, right, rightCell ); return; } 

त्रिभुज OSS और CCA।

डबल चट्टान

केवल शेष नॉनप्लेनार मामले दोनों तरफ चट्टानों के साथ कम कोशिकाएं हैं। इस मामले में, ऊपरी पसली कोई भी हो सकती है - फ्लैट, ढलान या चट्टान। हम केवल "क्लिफ-क्लिफ-स्लोप" मामले में रुचि रखते हैं, क्योंकि इसमें केवल लीड्स होंगे।

वास्तव में, "क्लिफ-क्लिफ-स्लोप" के दो अलग-अलग संस्करण हैं, जिनके आधार पर यह अधिक है। वे एक दूसरे के दर्पण चित्र हैं। आइए उन्हें ओओएसपी और ओओएसएल के रूप में नामित करें।




OOSP और OOSL।

हम TriangulateCornerकॉलिंग विधियों TriangulateCornerCliffTerracesऔर TriangulateCornerTerracesCliffविभिन्न सेल घुमावों के साथ दोनों मामलों को कवर कर सकते हैं ।

  if (leftEdgeType == HexEdgeType.Slope) { … } if (rightEdgeType == HexEdgeType.Slope) { … } if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope) { if (leftCell.Elevation < rightCell.Elevation) { TriangulateCornerCliffTerraces( right, rightCell, bottom, bottomCell, left, leftCell ); } else { TriangulateCornerTerracesCliff( left, leftCell, right, rightCell, bottom, bottomCell ); } return; } 

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

  void TriangulateCornerTerracesCliff ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { float b = 1f / (rightCell.Elevation - beginCell.Elevation); if (b < 0) { b = -b; } … } void TriangulateCornerCliffTerraces ( Vector3 begin, HexCell beginCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { float b = 1f / (leftCell.Elevation - beginCell.Elevation); if (b < 0) { b = -b; } … } 

त्रिभुज OOSP और OOSL।

मिटाना

हमने उन सभी मामलों की जांच की जिनके लिए विशेष हैंडलिंग की आवश्यकता है ताकि एलिगेंस के सही त्रिकोणासन को सुनिश्चित किया जा सके।


पूर्णांक के साथ त्रिकोणासन करें।

हम TriangulateCornerऑपरेटरों से छुटकारा पाने returnऔर ब्लॉकों के बजाय का उपयोग करके थोड़ा साफ कर सकते हैं else।

  void TriangulateCorner ( Vector3 bottom, HexCell bottomCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { HexEdgeType leftEdgeType = bottomCell.GetEdgeType(leftCell); HexEdgeType rightEdgeType = bottomCell.GetEdgeType(rightCell); if (leftEdgeType == HexEdgeType.Slope) { if (rightEdgeType == HexEdgeType.Slope) { TriangulateCornerTerraces( bottom, bottomCell, left, leftCell, right, rightCell ); } else if (rightEdgeType == HexEdgeType.Flat) { TriangulateCornerTerraces( left, leftCell, right, rightCell, bottom, bottomCell ); } else { TriangulateCornerTerracesCliff( bottom, bottomCell, left, leftCell, right, rightCell ); } } else if (rightEdgeType == HexEdgeType.Slope) { if (leftEdgeType == HexEdgeType.Flat) { TriangulateCornerTerraces( right, rightCell, bottom, bottomCell, left, leftCell ); } else { TriangulateCornerCliffTerraces( bottom, bottomCell, left, leftCell, right, rightCell ); } } else if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope) { if (leftCell.Elevation < rightCell.Elevation) { TriangulateCornerCliffTerraces( right, rightCell, bottom, bottomCell, left, leftCell ); } else { TriangulateCornerTerracesCliff( left, leftCell, right, rightCell, bottom, bottomCell ); } } else { AddTriangle(bottom, left, right); AddTriangleColor(bottomCell.color, leftCell.color, rightCell.color); } } 

पिछले ब्लॉक elseमें शेष सभी मामले शामिल हैं जिन्हें अभी तक कवर नहीं किया गया है। ये मामले हैं आरएफपी (प्लेन-प्लेन-प्लेन), ओओपी, एलएलसी और एलएलसी। वे सभी एक त्रिकोण द्वारा कवर किए गए हैं।


.

unitypackage