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

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

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

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

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

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

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

भाग 20: युद्ध का कोहरा

• बनावट में सेल डेटा को सहेजें।
• त्रिकोणासन के बिना राहत प्रकार बदलें।
• हम दृश्यता को ट्रैक करते हैं।
• अदृश्य सब कुछ अंधेरा।

इस भाग में, हम युद्ध प्रभाव के कोहरे को मानचित्र में जोड़ देंगे।

अब श्रृंखला एकता 2017.1.0 पर बनाई जाएगी।


अब हम देखते हैं कि हम देख सकते हैं और नहीं देख सकते हैं।

सेल डेटा Shader में

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

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

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

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

सेल डेटा प्रबंधन

हमें सेल डेटा युक्त बनावट को नियंत्रित करने के लिए एक तरीका चाहिए। चलो एक नया HexCellShaderData घटक HexCellShaderData हैं जो ऐसा करेगा।

 using UnityEngine; public class HexCellShaderData : MonoBehaviour { Texture2D cellTexture; } 

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

  public void Initialize (int x, int z) { cellTexture = new Texture2D( x, z, TextureFormat.RGBA32, false, true ); cellTexture.filterMode = FilterMode.Point; cellTexture.wrapMode = TextureWrapMode.Clamp; } 

वास्तव में, हमें हर बार एक नया नक्शा बनाने के लिए एक नई बनावट नहीं बनानी पड़ती। यह बनावट का आकार बदलने के लिए पर्याप्त है अगर यह पहले से मौजूद है। हमें यह भी जाँचने की आवश्यकता नहीं है कि क्या हमारे पास पहले से ही सही आकार है, क्योंकि Texture2D.Resize हमारे लिए ऐसा करने के लिए पर्याप्त स्मार्ट है।

  public void Initialize (int x, int z) { if (cellTexture) { cellTexture.Resize(x, z); } else { cellTexture = new Texture2D( cellCountX, cellCountZ, TextureFormat.RGBA32, false, true ); cellTexture.filterMode = FilterMode.Point; cellTexture.wrapMode = TextureWrapMode.Clamp; } } 

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

  Texture2D cellTexture; Color32[] cellTextureData; public void Initialize () { … if (cellTextureData == null || cellTextureData.Length != x * z) { cellTextureData = new Color32[x * z]; } else { for (int i = 0; i < cellTextureData.Length; i++) { cellTextureData[i] = new Color32(0, 0, 0, 0); } } } 

HexGrid को HexGrid में इन कोशिकाओं के निर्माण और आरंभीकरण से HexGrid चाहिए। इसलिए, हम इसमें cellShaderData फ़ील्ड cellShaderData और cellShaderData अंदर एक घटक बनाएंगे।

  HexCellShaderData cellShaderData; void Awake () { HexMetrics.noiseSource = noiseSource; HexMetrics.InitializeHashGrid(seed); HexUnit.unitPrefab = unitPrefab; cellShaderData = gameObject.AddComponent<HexCellShaderData>(); CreateMap(cellCountX, cellCountZ); } 

एक नया नक्शा बनाते समय, cellShaderData को भी cellShaderData किया जाना चाहिए।

  public bool CreateMap (int x, int z) { … cellCountX = x; cellCountZ = z; chunkCountX = cellCountX / HexMetrics.chunkSizeX; chunkCountZ = cellCountZ / HexMetrics.chunkSizeZ; cellShaderData.Initialize(cellCountX, cellCountZ); CreateChunks(); CreateCells(); return true; } 

सेल डेटा का संपादन

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

  public HexCellShaderData ShaderData { get; set; } 

HexGrid.CreateCell हम इस संपत्ति के लिए एक shader डेटा घटक असाइन HexGrid.CreateCell ।

  void CreateCell (int x, int z, int i) { … HexCell cell = cells[i] = Instantiate<HexCell>(cellPrefab); cell.transform.localPosition = position; cell.coordinates = HexCoordinates.FromOffsetCoordinates(x, z); cell.ShaderData = cellShaderData; … } 

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

एक विशिष्ट सेल के लिए इस कार्य को आसान बनाने के लिए RefreshTerrain एक HexCellShaderData विधि जोड़ें। चलिए इस विधि को अभी के लिए खाली छोड़ दें।

  public void RefreshTerrain (HexCell cell) { } 

HexCell.TerrainTypeIndex बदलें ताकि यह इस विधि को लागू करता है, और टुकड़ों को अपडेट करने का आदेश नहीं देता है।

  public int TerrainTypeIndex { get { return terrainTypeIndex; } set { if (terrainTypeIndex != value) { terrainTypeIndex = value; // Refresh(); ShaderData.RefreshTerrain(this); } } } 

हम इसे सेल टॉपोग्राफी प्रकार प्राप्त करने के बाद HexCell.Load में भी कहेंगे।

  public void Load (BinaryReader reader) { terrainTypeIndex = reader.ReadByte(); ShaderData.RefreshTerrain(this); elevation = reader.ReadByte(); RefreshPosition(); … } 

सेल इंडेक्स

इन कोशिकाओं को बदलने के लिए, हमें कोशिका के सूचकांक को जानना होगा। ऐसा करने का सबसे आसान तरीका है HexCell में Index प्रॉपर्टी को HexCell । यह मानचित्र में कोशिकाओं की सूची में सेल के सूचकांक को इंगित करेगा, जो शेडर में दी गई कोशिकाओं में इसके सूचकांक से मेल खाती है।

  public int Index { get; set; } 

यह सूचकांक पहले से ही HexGrid.CreateCell , इसलिए बस इसे बनाए गए सेल में असाइन करें।

  void CreateCell (int x, int z, int i) { … cell.coordinates = HexCoordinates.FromOffsetCoordinates(x, z); cell.Index = i; cell.ShaderData = cellShaderData; … } 

अब HexCellShaderData.RefreshTerrain सेल डेटा को निर्दिष्ट करने के लिए इस इंडेक्स का उपयोग कर सकता है। आइए अपने पिक्सेल के अल्फा घटक में उन्नयन प्रकार के सूचकांक को केवल बाइट के प्रकार में परिवर्तित करके सहेजें। यह 256 प्रकार के इलाकों का समर्थन करेगा, जो हमारे लिए पर्याप्त होगा।

  public void RefreshTerrain (HexCell cell) { cellTextureData[cell.Index].a = (byte)cell.TerrainTypeIndex; } 

एक बनावट में डेटा को लागू करने और इसे GPU में पास करने के लिए, हमें Texture2D.SetPixels32 और उसके बाद Texture2D.Apply पर कॉल करना होगा। खंडों के मामले में, हम LateUpdate पर इन कार्यों को स्थगित कर देंगे ताकि वे बदले हुए कोशिकाओं की संख्या की परवाह किए बिना फ्रेम के अनुसार एक बार से अधिक बार प्रदर्शन न कर सकें।

  public void RefreshTerrain (HexCell cell) { cellTextureData[cell.Index].a = (byte)cell.TerrainTypeIndex; enabled = true; } void LateUpdate () { cellTexture.SetPixels32(cellTextureData); cellTexture.Apply(); enabled = false; } 

यह सुनिश्चित करने के लिए कि नया मानचित्र बनाने के बाद डेटा अपडेट किया जाएगा, प्रारंभ के बाद घटक को सक्षम करें।

  public void Initialize (int x, int z) { … enabled = true; } 

सेल सूचकांकों का त्रिकोणासन

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

हम useTerrainTypes अप्रचलित आम फ़ील्ड useColors और useTerrainTypes । उन्हें एक useCellData साथ बदलें।

 // public bool useCollider, useColors, useUVCoordinates, useUV2Coordinates; // public bool useTerrainTypes; public bool useCollider, useCellData, useUVCoordinates, useUV2Coordinates; 

हम cellIndices सूची का नाम बदलकर cellIndices करने का cellIndices । चलो cellWeights - cellWeights को cellWeights -रीनेम नाम भी दें - यह नाम बेहतर करेगा।

 // [NonSerialized] List<Vector3> vertices, terrainTypes; // [NonSerialized] List<Color> colors; [NonSerialized] List<Vector3> vertices, cellIndices; [NonSerialized] List<Color> cellWeights; [NonSerialized] List<Vector2> uvs, uv2s; [NonSerialized] List<int> triangles; 

चेंज Clear ताकि इन कोशिकाओं का उपयोग करते समय, इसे दो सूचियाँ एक साथ मिलें, और अलग से नहीं।

  public void Clear () { hexMesh.Clear(); vertices = ListPool<Vector3>.Get(); if (useCellData) { cellWeights = ListPool<Color>.Get(); cellIndices = ListPool<Vector3>.Get(); } // if (useColors) { // colors = ListPool<Color>.Get(); // } if (useUVCoordinates) { uvs = ListPool<Vector2>.Get(); } if (useUV2Coordinates) { uv2s = ListPool<Vector2>.Get(); } // if (useTerrainTypes) { // terrainTypes = ListPool<Vector3>.Get(); // } triangles = ListPool<int>.Get(); } 

अप्लाई में एक ही ग्रुपिंग Apply ।

  public void Apply () { hexMesh.SetVertices(vertices); ListPool<Vector3>.Add(vertices); if (useCellData) { hexMesh.SetColors(cellWeights); ListPool<Color>.Add(cellWeights); hexMesh.SetUVs(2, cellIndices); ListPool<Vector3>.Add(cellIndices); } // if (useColors) { // hexMesh.SetColors(colors); // ListPool<Color>.Add(colors); // } if (useUVCoordinates) { hexMesh.SetUVs(0, uvs); ListPool<Vector2>.Add(uvs); } if (useUV2Coordinates) { hexMesh.SetUVs(1, uv2s); ListPool<Vector2>.Add(uv2s); } // if (useTerrainTypes) { // hexMesh.SetUVs(2, terrainTypes); // ListPool<Vector3>.Add(terrainTypes); // } hexMesh.SetTriangles(triangles, 0); ListPool<int>.Add(triangles); hexMesh.RecalculateNormals(); if (useCollider) { meshCollider.sharedMesh = hexMesh; } } 

सभी AddTriangleColor और AddTriangleTerrainTypes हटा दें। उन्हें उपयुक्त AddTriangleCellData विधियों से बदलें, जो एक समय में अनुक्रमित और भार जोड़ते हैं।

  public void AddTriangleCellData ( Vector3 indices, Color weights1, Color weights2, Color weights3 ) { cellIndices.Add(indices); cellIndices.Add(indices); cellIndices.Add(indices); cellWeights.Add(weights1); cellWeights.Add(weights2); cellWeights.Add(weights3); } public void AddTriangleCellData (Vector3 indices, Color weights) { AddTriangleCellData(indices, weights, weights, weights); } 

उपयुक्त AddQuad विधि में ही करें।

  public void AddQuadCellData ( Vector3 indices, Color weights1, Color weights2, Color weights3, Color weights4 ) { cellIndices.Add(indices); cellIndices.Add(indices); cellIndices.Add(indices); cellIndices.Add(indices); cellWeights.Add(weights1); cellWeights.Add(weights2); cellWeights.Add(weights3); cellWeights.Add(weights4); } public void AddQuadCellData ( Vector3 indices, Color weights1, Color weights2 ) { AddQuadCellData(indices, weights1, weights1, weights2, weights2); } public void AddQuadCellData (Vector3 indices, Color weights) { AddQuadCellData(indices, weights, weights, weights, weights); } 

HexGridChunk रिफैक्टिंग

इस स्तर पर, हमें HexGridChunk में बहुत अधिक कंपाइलर त्रुटियां HexGridChunk जिन्हें HexGridChunk करने की आवश्यकता है। लेकिन सबसे पहले, स्थिरता के लिए, हम वजन के लिए स्थिर रंगों को फिर से रंगते हैं।

  static Color weights1 = new Color(1f, 0f, 0f); static Color weights2 = new Color(0f, 1f, 0f); static Color weights3 = new Color(0f, 0f, 1f); 

चलिए TriangulateEdgeFan को ठीक करके शुरू करते हैं। उसे एक प्रकार की आवश्यकता थी, लेकिन अब उसे एक सेल इंडेक्स की आवश्यकता है। AddTriangleTerrainTypes कोड के साथ AddTriangleColor और AddTriangleTerrainTypes कोड को AddTriangleColor ।

  void TriangulateEdgeFan (Vector3 center, EdgeVertices edge, float index) { terrain.AddTriangle(center, edge.v1, edge.v2); terrain.AddTriangle(center, edge.v2, edge.v3); terrain.AddTriangle(center, edge.v3, edge.v4); terrain.AddTriangle(center, edge.v4, edge.v5); Vector3 indices; indices.x = indices.y = indices.z = index; terrain.AddTriangleCellData(indices, weights1); terrain.AddTriangleCellData(indices, weights1); terrain.AddTriangleCellData(indices, weights1); terrain.AddTriangleCellData(indices, weights1); // terrain.AddTriangleColor(weights1); // terrain.AddTriangleColor(weights1); // terrain.AddTriangleColor(weights1); // terrain.AddTriangleColor(weights1); // Vector3 types; // types.x = types.y = types.z = type; // terrain.AddTriangleTerrainTypes(types); // terrain.AddTriangleTerrainTypes(types); // terrain.AddTriangleTerrainTypes(types); // terrain.AddTriangleTerrainTypes(types); } 

इस विधि को कई स्थानों पर कहा जाता है। आइए उनके ऊपर जाएं और सुनिश्चित करें कि सेल का सूचकांक वहां स्थानांतरित किया गया है, न कि इलाके का प्रकार।

  TriangulateEdgeFan(center, e, cell.Index); 

अगला TriangulateEdgeStrip । यहां सब कुछ थोड़ा अधिक जटिल है, लेकिन हम उसी दृष्टिकोण का उपयोग करते हैं। इसके अलावा रिफ्लैक्टर-रीनेम का नाम c1 और c2 से w1 और w2 ।

  void TriangulateEdgeStrip ( EdgeVertices e1, Color w1, float index1, EdgeVertices e2, Color w2, float index2, bool hasRoad = false ) { terrain.AddQuad(e1.v1, e1.v2, e2.v1, e2.v2); terrain.AddQuad(e1.v2, e1.v3, e2.v2, e2.v3); terrain.AddQuad(e1.v3, e1.v4, e2.v3, e2.v4); terrain.AddQuad(e1.v4, e1.v5, e2.v4, e2.v5); Vector3 indices; indices.x = indices.z = index1; indices.y = index2; terrain.AddQuadCellData(indices, w1, w2); terrain.AddQuadCellData(indices, w1, w2); terrain.AddQuadCellData(indices, w1, w2); terrain.AddQuadCellData(indices, w1, w2); // terrain.AddQuadColor(c1, c2); // terrain.AddQuadColor(c1, c2); // terrain.AddQuadColor(c1, c2); // terrain.AddQuadColor(c1, c2); // Vector3 types; // types.x = types.z = type1; // types.y = type2; // terrain.AddQuadTerrainTypes(types); // terrain.AddQuadTerrainTypes(types); // terrain.AddQuadTerrainTypes(types); // terrain.AddQuadTerrainTypes(types); if (hasRoad) { TriangulateRoadSegment(e1.v2, e1.v3, e1.v4, e2.v2, e2.v3, e2.v4); } } 

कॉल को इस विधि में बदलें ताकि सेल इंडेक्स उनके पास पहुंच जाए। हम चर नामों को भी सुसंगत रखते हैं।

  TriangulateEdgeStrip( m, weights1, cell.Index, e, weights1, cell.Index ); … TriangulateEdgeStrip( e1, weights1, cell.Index, e2, weights2, neighbor.Index, hasRoad ); … void TriangulateEdgeTerraces ( EdgeVertices begin, HexCell beginCell, EdgeVertices end, HexCell endCell, bool hasRoad ) { EdgeVertices e2 = EdgeVertices.TerraceLerp(begin, end, 1); Color w2 = HexMetrics.TerraceLerp(weights1, weights2, 1); float i1 = beginCell.Index; float i2 = endCell.Index; TriangulateEdgeStrip(begin, weights1, i1, e2, w2, i2, hasRoad); for (int i = 2; i < HexMetrics.terraceSteps; i++) { EdgeVertices e1 = e2; Color w1 = w2; e2 = EdgeVertices.TerraceLerp(begin, end, i); w2 = HexMetrics.TerraceLerp(weights1, weights2, i); TriangulateEdgeStrip(e1, w1, i1, e2, w2, i2, hasRoad); } TriangulateEdgeStrip(e2, w2, i1, end, weights2, i2, hasRoad); } 

अब हम कोण विधियों पर चलते हैं। ये परिवर्तन सरल हैं, लेकिन इन्हें बड़ी मात्रा में कोड बनाने की आवश्यकता है। सबसे पहले TriangulateCorner ।

  void TriangulateCorner ( Vector3 bottom, HexCell bottomCell, Vector3 left, HexCell leftCell, Vector3 right, HexCell rightCell ) { … else { terrain.AddTriangle(bottom, left, right); Vector3 indices; indices.x = bottomCell.Index; indices.y = leftCell.Index; indices.z = rightCell.Index; terrain.AddTriangleCellData(indices, weights1, weights2, weights3); // terrain.AddTriangleColor(weights1, weights2, weights3); // Vector3 types; // types.x = bottomCell.TerrainTypeIndex; // types.y = leftCell.TerrainTypeIndex; // types.z = rightCell.TerrainTypeIndex; // terrain.AddTriangleTerrainTypes(types); } features.AddWall(bottom, bottomCell, left, leftCell, right, rightCell); } 

TriangulateCornerTerraces में आगे।

  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 w3 = HexMetrics.TerraceLerp(weights1, weights2, 1); Color w4 = HexMetrics.TerraceLerp(weights1, weights3, 1); Vector3 indices; indices.x = beginCell.Index; indices.y = leftCell.Index; indices.z = rightCell.Index; terrain.AddTriangle(begin, v3, v4); terrain.AddTriangleCellData(indices, weights1, w3, w4); // terrain.AddTriangleColor(weights1, w3, w4); // terrain.AddTriangleTerrainTypes(indices); for (int i = 2; i < HexMetrics.terraceSteps; i++) { Vector3 v1 = v3; Vector3 v2 = v4; Color w1 = w3; Color w2 = w4; v3 = HexMetrics.TerraceLerp(begin, left, i); v4 = HexMetrics.TerraceLerp(begin, right, i); w3 = HexMetrics.TerraceLerp(weights1, weights2, i); w4 = HexMetrics.TerraceLerp(weights1, weights3, i); terrain.AddQuad(v1, v2, v3, v4); terrain.AddQuadCellData(indices, w1, w2, w3, w4); // terrain.AddQuadColor(w1, w2, w3, w4); // terrain.AddQuadTerrainTypes(indices); } terrain.AddQuad(v3, v4, left, right); terrain.AddQuadCellData(indices, w3, w4, weights2, weights3); // terrain.AddQuadColor(w3, w4, weights2, weights3); // terrain.AddQuadTerrainTypes(indices); } 

फिर TriangulateCornerTerracesCliff ।

  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; } Vector3 boundary = Vector3.Lerp( HexMetrics.Perturb(begin), HexMetrics.Perturb(right), b ); Color boundaryWeights = Color.Lerp(weights1, weights3, b); Vector3 indices; indices.x = beginCell.Index; indices.y = leftCell.Index; indices.z = rightCell.Index; TriangulateBoundaryTriangle( begin, weights1, left, weights2, boundary, boundaryWeights, indices ); if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope) { TriangulateBoundaryTriangle( left, weights2, right, weights3, boundary, boundaryWeights, indices ); } else { terrain.AddTriangleUnperturbed( HexMetrics.Perturb(left), HexMetrics.Perturb(right), boundary ); terrain.AddTriangleCellData( indices, weights2, weights3, boundaryWeights ); // terrain.AddTriangleColor(weights2, weights3, boundaryColor); // terrain.AddTriangleTerrainTypes(indices); } } 

और TriangulateCornerCliffTerraces में थोड़ा अलग।

  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; } Vector3 boundary = Vector3.Lerp( HexMetrics.Perturb(begin), HexMetrics.Perturb(left), b ); Color boundaryWeights = Color.Lerp(weights1, weights2, b); Vector3 indices; indices.x = beginCell.Index; indices.y = leftCell.Index; indices.z = rightCell.Index; TriangulateBoundaryTriangle( right, weights3, begin, weights1, boundary, boundaryWeights, indices ); if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope) { TriangulateBoundaryTriangle( left, weights2, right, weights3, boundary, boundaryWeights, indices ); } else { terrain.AddTriangleUnperturbed( HexMetrics.Perturb(left), HexMetrics.Perturb(right), boundary ); terrain.AddTriangleCellData( indices, weights2, weights3, boundaryWeights ); // terrain.AddTriangleColor(weights2, weights3, boundaryWeights); // terrain.AddTriangleTerrainTypes(indices); } } 

पिछले दो तरीके TriangulateBoundaryTriangle उपयोग करते हैं, जिसे अपडेट करने की भी आवश्यकता होती है।

  void TriangulateBoundaryTriangle ( Vector3 begin, Color beginWeights, Vector3 left, Color leftWeights, Vector3 boundary, Color boundaryWeights, Vector3 indices ) { Vector3 v2 = HexMetrics.Perturb(HexMetrics.TerraceLerp(begin, left, 1)); Color w2 = HexMetrics.TerraceLerp(beginWeights, leftWeights, 1); terrain.AddTriangleUnperturbed(HexMetrics.Perturb(begin), v2, boundary); terrain.AddTriangleCellData(indices, beginWeights, w2, boundaryWeights); // terrain.AddTriangleColor(beginColor, c2, boundaryColor); // terrain.AddTriangleTerrainTypes(types); for (int i = 2; i < HexMetrics.terraceSteps; i++) { Vector3 v1 = v2; Color w1 = w2; v2 = HexMetrics.Perturb(HexMetrics.TerraceLerp(begin, left, i)); w2 = HexMetrics.TerraceLerp(beginWeights, leftWeights, i); terrain.AddTriangleUnperturbed(v1, v2, boundary); terrain.AddTriangleCellData(indices, w1, w2, boundaryWeights); // terrain.AddTriangleColor(c1, c2, boundaryColor); // terrain.AddTriangleTerrainTypes(types); } terrain.AddTriangleUnperturbed(v2, HexMetrics.Perturb(left), boundary); terrain.AddTriangleCellData(indices, w2, leftWeights, boundaryWeights); // terrain.AddTriangleColor(c2, leftColor, boundaryColor); // terrain.AddTriangleTerrainTypes(types); } 

अंतिम विधि जिसे बदलने की आवश्यकता है, वह है TriangulateWithRiver ।

  void TriangulateWithRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { … terrain.AddTriangle(centerL, m.v1, m.v2); terrain.AddQuad(centerL, center, m.v2, m.v3); terrain.AddQuad(center, centerR, m.v3, m.v4); terrain.AddTriangle(centerR, m.v4, m.v5); Vector3 indices; indices.x = indices.y = indices.z = cell.Index; terrain.AddTriangleCellData(indices, weights1); terrain.AddQuadCellData(indices, weights1); terrain.AddQuadCellData(indices, weights1); terrain.AddTriangleCellData(indices, weights1); // terrain.AddTriangleColor(weights1); // terrain.AddQuadColor(weights1); // terrain.AddQuadColor(weights1); // terrain.AddTriangleColor(weights1); // Vector3 types; // types.x = types.y = types.z = cell.TerrainTypeIndex; // terrain.AddTriangleTerrainTypes(types); // terrain.AddQuadTerrainTypes(types); // terrain.AddQuadTerrainTypes(types); // terrain.AddTriangleTerrainTypes(types); … } 

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


राहत सेल डेटा का उपयोग करता है।

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


सेल सूचकांकों का उपयोग ऊंचाई बनावट सूचकांकों के रूप में करना।

सेल डेटा को shader में स्थानांतरित करें

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

सेल बनावट बनाने के बाद, इसे Shader.SetGlobalTexture विधि से कॉल करें, ताकि यह विश्व स्तर पर _HexCDData के रूप में दिखाई दे।

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

शेडर प्रॉपर्टी का उपयोग करते समय, यूनिटी टेक्सचर आकार को बनावट के माध्यम से उपलब्ध करवाती है ।Name_TexelSize वेरिएबल। यह एक चार-घटक सदिश है जिसमें मान हैं जो चौड़ाई और ऊंचाई के विपरीत हैं, साथ ही साथ चौड़ाई और ऊंचाई भी। लेकिन वैश्विक बनावट सेट करते समय, यह प्रदर्शन नहीं किया जाता है। इसलिए, हम बनावट बनाने या आकार बदलने के बाद इसे Shader.SetGlobalVector का उपयोग करके स्वयं करेंगे।

  else { cellTexture = new Texture2D( x, z, TextureFormat.RGBA32, false, true ); cellTexture.filterMode = FilterMode.Point; cellTexture.wrapMode = TextureWrapMode.Clamp; Shader.SetGlobalTexture("_HexCellData", cellTexture); } Shader.SetGlobalVector( "_HexCellData_TexelSize", new Vector4(1f / x, 1f / z, x, z) ); 

Shader Data Access

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

 sampler2D _HexCellData; float4 _HexCellData_TexelSize; float4 GetCellData (appdata_full v) { } 

नई फ़ाइल में शामिल हैं।

सेल सूचकांकों को v.texcoord2 में संग्रहीत किया v.texcoord2 , जैसा कि इलाक़े के प्रकारों में होता था। पहले सूचकांक के साथ शुरू करते हैं - v.texcoord2.x । दुर्भाग्य से, हम इन कोशिकाओं की बनावट के नमूने के लिए सीधे सूचकांक का उपयोग नहीं कर सकते हैं। हमें इसे यूवी निर्देशांक में बदलना होगा।

यू समन्वय बनाने में पहला कदम बनावट की चौड़ाई से सेल इंडेक्स को विभाजित करना है। हम इसे _HexCellData_TexelSize.x द्वारा गुणा करके कर सकते हैं।

 float4 GetCellData (appdata_full v) { float2 uv; uv.x = v.texcoord2.x * _HexCellData_TexelSize.x; } 

परिणाम ZU के रूप में एक संख्या होगी, जहां Z पंक्ति सूचकांक है और U, U सेल का समन्वय है। हम संख्या को नीचे लाकर स्ट्रिंग को निकाल सकते हैं और फिर यू समन्वय प्राप्त करने के लिए इसे संख्या से घटा सकते हैं।

 float4 GetCellData (appdata_full v) { float2 uv; uv.x = v.texcoord2.x * _HexCellData_TexelSize.x; float row = floor(uv.x); uv.x -= row; } 

V निर्देशांक बनावट की ऊंचाई से रेखा को विभाजित कर रहा है।

 float4 GetCellData (appdata_full v) { float2 uv; uv.x = v.texcoord2.x * _HexCellData_TexelSize.x; float row = floor(uv.x); uv.x -= row; uv.y = row * _HexCellData_TexelSize.y; } 

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

 float4 GetCellData (appdata_full v) { float2 uv; uv.x = (v.texcoord2.x + 0.5) * _HexCellData_TexelSize.x; float row = floor(uv.x); uv.x -= row; uv.y = (row + 0.5) * _HexCellData_TexelSize.y; } 

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

 float4 GetCellData (appdata_full v, int index) { float2 uv; uv.x = (v.texcoord2[index] + 0.5) * _HexCellData_TexelSize.x; float row = floor(uv.x); uv.x -= row; uv.y = (row + 0.5) * _HexCellData_TexelSize.y; } 

अब जब हमारे पास इन कोशिकाओं के लिए सभी आवश्यक निर्देशांक हैं, तो हम नमूना ले सकते हैं _HexCellData। चूँकि हम वर्टेक्स प्रोग्राम में बनावट का नमूना ले रहे हैं, हमें स्पष्ट रूप से उस शेप को बताना होगा जो बनावट का उपयोग करता है। यह एक फ़ंक्शन का उपयोग करके किया जा सकता है tex2Dlodजिसमें चार बनावट के निर्देशांक की आवश्यकता होती है। चूंकि इन कोशिकाओं में एमआईपी-बनावट नहीं है, इसलिए हम अतिरिक्त निर्देशांक को शून्य मान प्रदान करते हैं।

 float4 GetCellData (appdata_full v, int index) { float2 uv; uv.x = (v.texcoord2[index] + 0.5) * _HexCellData_TexelSize.x; float row = floor(uv.x); uv.x -= row; uv.y = (row + 0.5) * _HexCellData_TexelSize.y; float4 data = tex2Dlod(_HexCellData, float4(uv, 0, 0)); } 

चौथे डेटा घटक में एक ऊंचाई प्रकार का सूचकांक होता है, जिसे हम सीधे बाइट्स के रूप में संग्रहीत करते हैं। हालांकि, GPU ने स्वचालित रूप से इसे 0-2 की सीमा में एक फ्लोटिंग पॉइंट मान में बदल दिया। इसे वापस सही मान में बदलने के लिए, इसे 255 से गुणा करें। इसके बाद, आप डेटा वापस कर सकते हैं।

  float4 data = tex2Dlod(_HexCellData, float4(uv, 0, 0)); data.w *= 255; return data; 

इस कार्यक्षमता का उपयोग करने के लिए हमें शामिल HexCellData शेडर में भू-भाग । जब से मैंने इस shader को Material / Terrain में रखा है , मुझे सापेक्ष पथ का उपयोग करने की आवश्यकता है ../HexCellData.cginc ।

  #include "../HexCellData.cginc" UNITY_DECLARE_TEX2DARRAY(_MainTex); 

शीर्ष प्रोग्राम में, हम शीर्ष डेटा में संग्रहीत सभी तीन सेल सूचकांकों के लिए सेल डेटा प्राप्त करते हैं। फिर data.terrainउनके उन्नयन सूचकांकों को असाइन करें ।

  void vert (inout appdata_full v, out Input data) { UNITY_INITIALIZE_OUTPUT(Input, data); // data.terrain = v.texcoord2.xyz; float4 cell0 = GetCellData(v, 0); float4 cell1 = GetCellData(v, 1); float4 cell2 = GetCellData(v, 2); data.terrain.x = cell0.w; data.terrain.y = cell1.w; data.terrain.z = cell2.w; } 

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

unitypackage

दृश्यता

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

शेडर

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

  struct Input { float4 color : COLOR; float3 worldPos; float3 terrain; float3 visibility; }; 

दृश्यता को संग्रहीत करने के लिए, हम इन कोशिकाओं के पहले घटक का उपयोग करते हैं।

  void vert (inout appdata_full v, out Input data) { UNITY_INITIALIZE_OUTPUT(Input, data); float4 cell0 = GetCellData(v, 0); float4 cell1 = GetCellData(v, 1); float4 cell2 = GetCellData(v, 2); data.terrain.x = cell0.w; data.terrain.y = cell1.w; data.terrain.z = cell2.w; data.visibility.x = cell0.x; data.visibility.y = cell1.x; data.visibility.z = cell2.x; } 

0 की दृश्यता का मतलब है कि सेल वर्तमान में अदृश्य है। यदि यह दिखाई देता है, तो यह दृश्यता का मान होगा। इसलिए, हम GetTerrainColorदृश्यता के संगत वेक्टर द्वारा परिणाम को गुणा करके इलाके को काला कर सकते हैं । इस प्रकार, हम व्यक्तिगत रूप से प्रत्येक मिश्रित सेल के राहत रंग को संशोधित करते हैं।

  float4 GetTerrainColor (Input IN, int index) { float3 uvw = float3(IN.worldPos.xz * 0.02, IN.terrain[index]); float4 c = UNITY_SAMPLE_TEX2DARRAY(_MainTex, uvw); return c * (IN.color[index] * IN.visibility[index]); } 

कोशिकाएं काली हो गईं।


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

  void vert (inout appdata_full v, out Input data) { … data.visibility.x = cell0.x; data.visibility.y = cell1.x; data.visibility.z = cell2.x; data.visibility = lerp(0.25, 1, data.visibility); } 

छायांकित कोशिकाएँ।

सेल दृश्यता ट्रैकिंग

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

  public bool IsVisible { get { return visibility > 0; } } … int visibility; … public void IncreaseVisibility () { visibility += 1; } public void DecreaseVisibility () { visibility -= 1; } 

इसके बाद, उस HexCellShaderDataविधि में जोड़ें RefreshVisibility, जो RefreshTerrainदृश्यता के लिए जैसा है वैसा ही करती है। डेटा कोशिकाओं के घटक आर में डेटा सहेजें। चूँकि हम बाइट्स के साथ काम करते हैं जो 0-1 मानों में बदल जाते हैं, हम दृश्यता को इंगित करने के लिए उपयोग करते हैं (byte)255।

  public void RefreshVisibility (HexCell cell) { cellTextureData[cell.Index].r = cell.IsVisible ? (byte)255 : (byte)0; enabled = true; } 

हम इस पद्धति को बढ़ते और घटते दृश्यता के साथ कहेंगे, 0 और 1 के बीच के मान को बदलते हुए।

  public void IncreaseVisibility () { visibility += 1; if (visibility == 1) { ShaderData.RefreshVisibility(this); } } public void DecreaseVisibility () { visibility -= 1; if (visibility == 0) { ShaderData.RefreshVisibility(this); } } 

स्क्वाड दृश्यता बनाना

आइए इसे बनाते हैं ताकि इकाइयाँ उस कक्ष को देख सकें, जिस पर उनका कब्जा है। यह IncreaseVisibilityकार्य के दौरान यूनिट के नए स्थान पर कॉल का उपयोग करके पूरा किया जाता है HexUnit.Location। हम पुराने स्थान के लिए भी कॉल करते हैं (यदि यह मौजूद है) DecreaseVisibility।

  public HexCell Location { get { return location; } set { if (location) { location.DecreaseVisibility(); location.Unit = null; } location = value; value.Unit = this; value.IncreaseVisibility(); transform.localPosition = value.Position; } } 

इकाइयाँ देख सकती हैं कि वे कहाँ हैं।

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

  public void Die () { if (location) { location.DecreaseVisibility(); } location.Unit = null; Destroy(gameObject); } 

दृश्यता सीमा

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

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

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

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

  List<HexCell> GetVisibleCells (HexCell fromCell, int range) { List<HexCell> visibleCells = ListPool<HexCell>.Get(); searchFrontierPhase += 2; if (searchFrontier == null) { searchFrontier = new HexCellPriorityQueue(); } else { searchFrontier.Clear(); } fromCell.SearchPhase = searchFrontierPhase; fromCell.Distance = 0; searchFrontier.Enqueue(fromCell); while (searchFrontier.Count > 0) { HexCell current = searchFrontier.Dequeue(); current.SearchPhase += 1; visibleCells.Add(current); // if (current == toCell) { // return true; // } // int currentTurn = (current.Distance - 1) / speed; for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = current.GetNeighbor(d); if ( neighbor == null || neighbor.SearchPhase > searchFrontierPhase ) { continue; } // … // int moveCost; // … int distance = current.Distance + 1; if (distance > range) { continue; } // int turn = (distance - 1) / speed; // if (turn > currentTurn) { // distance = turn * speed + moveCost; // } if (neighbor.SearchPhase < searchFrontierPhase) { neighbor.SearchPhase = searchFrontierPhase; neighbor.Distance = distance; // neighbor.PathFrom = current; neighbor.SearchHeuristic = 0; searchFrontier.Enqueue(neighbor); } else if (distance < neighbor.Distance) { int oldPriority = neighbor.SearchPriority; neighbor.Distance = distance; // neighbor.PathFrom = current; searchFrontier.Change(neighbor, oldPriority); } } } return visibleCells; } 

इसके अलावा HexGridतरीके IncreaseVisibilityऔर जोड़ें DecreaseVisibility। वे सेल और रेंज प्राप्त करते हैं, संबंधित कोशिकाओं की एक सूची लेते हैं और उनकी दृश्यता में वृद्धि / कमी करते हैं। जब किया जाता है, तो उन्हें सूची को उसके पूल में वापस करना चाहिए।

  public void IncreaseVisibility (HexCell fromCell, int range) { List<HexCell> cells = GetVisibleCells(fromCell, range); for (int i = 0; i < cells.Count; i++) { cells[i].IncreaseVisibility(); } ListPool<HexCell>.Add(cells); } public void DecreaseVisibility (HexCell fromCell, int range) { List<HexCell> cells = GetVisibleCells(fromCell, range); for (int i = 0; i < cells.Count; i++) { cells[i].DecreaseVisibility(); } ListPool<HexCell>.Add(cells); } 

इन विधियों का HexUnitउपयोग करने के लिए ग्रिड तक पहुंच की आवश्यकता होती है, इसलिए इसमें एक संपत्ति जोड़ें Grid।

  public HexGrid Grid { get; set; } 

जब आप ग्रिड में एक स्क्वाड जोड़ते हैं, तो यह इस संपत्ति को ग्रिड असाइन करेगा 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; } 

शुरू करने के लिए, तीन कोशिकाओं की दृश्यता की सीमा पर्याप्त होगी। ऐसा करने के लिए, हम HexUnitस्थिरांक को जोड़ते हैं , जो भविष्य में हमेशा एक चर में बदल सकता है। फिर हम ग्रिड के लिए दस्ते के आह्वान के तरीके बनाएंगे IncreaseVisibilityऔर DecreaseVisibilityइसकी दृश्यता सीमा को भी प्रेषित करेंगे, न कि केवल इस स्थान पर जाएं।

  const int visionRange = 3; … public HexCell Location { get { return location; } set { if (location) { // location.DecreaseVisibility(); Grid.DecreaseVisibility(location, visionRange); location.Unit = null; } location = value; value.Unit = this; // value.IncreaseVisibility(); Grid.IncreaseVisibility(value, visionRange); transform.localPosition = value.Position; } } … public void Die () { if (location) { // location.DecreaseVisibility(); Grid.DecreaseVisibility(location, visionRange); } location.Unit = null; Destroy(gameObject); } 

दृश्यता रेंज वाली इकाइयाँ जो ओवरलैप हो सकती हैं।

चलते समय दृश्यता

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

  public void Travel (List<HexCell> path) { // Location = path[path.Count - 1]; location.Unit = null; location = path[path.Count - 1]; location.Unit = this; pathToTravel = path; StopAllCoroutines(); StartCoroutine(TravelPath()); } 

कोरआउट के अंदर, TravelPathहम पूर्ण होने के बाद ही पहली सेल की दृश्यता को कम कर देंगे LookAt। उसके बाद, एक नए सेल में जाने से पहले, हम इस सेल से दृश्यता बढ़ाएंगे। इसके साथ समाप्त होने के बाद, हम फिर से दृश्यता कम कर देते हैं। अंत में, अंतिम सेल से दृश्यता बढ़ाएं।

  IEnumerator TravelPath () { Vector3 a, b, c = pathToTravel[0].Position; // transform.localPosition = c; yield return LookAt(pathToTravel[1].Position); Grid.DecreaseVisibility(pathToTravel[0], visionRange); float t = Time.deltaTime * travelSpeed; for (int i = 1; i < pathToTravel.Count; i++) { a = c; b = pathToTravel[i - 1].Position; c = (b + pathToTravel[i].Position) * 0.5f; Grid.IncreaseVisibility(pathToTravel[i], visionRange); for (; t < 1f; t += Time.deltaTime * travelSpeed) { … } Grid.DecreaseVisibility(pathToTravel[i], visionRange); t -= 1f; } a = c; b = location.Position; // We can simply use the destination here. c = b; Grid.IncreaseVisibility(location, visionRange); for (; t < 1f; t += Time.deltaTime * travelSpeed) { … } … } 

इस कदम पर दृश्यता।

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

  HexCell location, currentTravelLocation; 

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

  IEnumerator TravelPath () { … 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); for (; t < 1f; t += Time.deltaTime * travelSpeed) { transform.localPosition = Bezier.GetPoint(a, b, c, t); Vector3 d = Bezier.GetDerivative(a, b, c, t); dy = 0f; transform.localRotation = Quaternion.LookRotation(d); yield return null; } Grid.DecreaseVisibility(pathToTravel[i], visionRange); t -= 1f; } currentTravelLocation = null; … } 

अब बारी को पूरा करने के बाद, TravelPathहम जांच कर सकते हैं कि पथ का पुराना मध्यवर्ती स्थान ज्ञात है या नहीं। यदि हाँ, तो आपको इस सेल में दृश्यता कम करने की आवश्यकता है, न कि पथ की शुरुआत में।

  IEnumerator TravelPath () { Vector3 a, b, c = pathToTravel[0].Position; yield return LookAt(pathToTravel[1].Position); Grid.DecreaseVisibility( currentTravelLocation ? currentTravelLocation : pathToTravel[0], visionRange ); … } 

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

  void OnEnable () { if (location) { transform.localPosition = location.Position; if (currentTravelLocation) { Grid.IncreaseVisibility(location, visionRange); Grid.DecreaseVisibility(currentTravelLocation, visionRange); currentTravelLocation = null; } } } 

unitypackage

सड़कों और पानी की दृश्यता

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

सड़कों

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

  void TriangulateRoadEdge ( Vector3 center, Vector3 mL, Vector3 mR, float index ) { roads.AddTriangle(center, mL, mR); roads.AddTriangleUV( new Vector2(1f, 0f), new Vector2(0f, 0f), new Vector2(0f, 0f) ); Vector3 indices; indices.x = indices.y = indices.z = index; roads.AddTriangleCellData(indices, weights1); } 

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

  void TriangulateRoadSegment ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, Vector3 v5, Vector3 v6, Color w1, Color w2, Vector3 indices ) { roads.AddQuad(v1, v2, v4, v5); roads.AddQuad(v2, v3, v5, v6); roads.AddQuadUV(0f, 1f, 0f, 0f); roads.AddQuadUV(1f, 0f, 0f, 0f); roads.AddQuadCellData(indices, w1, w2); roads.AddQuadCellData(indices, w1, w2); } 

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

  void TriangulateRoad ( Vector3 center, Vector3 mL, Vector3 mR, EdgeVertices e, bool hasRoadThroughCellEdge, float index ) { if (hasRoadThroughCellEdge) { Vector3 indices; indices.x = indices.y = indices.z = index; Vector3 mC = Vector3.Lerp(mL, mR, 0.5f); TriangulateRoadSegment( mL, mC, mR, e.v2, e.v3, e.v4, weights1, weights1, indices ); roads.AddTriangle(center, mL, mC); roads.AddTriangle(center, mC, mR); roads.AddTriangleUV( new Vector2(1f, 0f), new Vector2(0f, 0f), new Vector2(1f, 0f) ); roads.AddTriangleUV( new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(0f, 0f) ); roads.AddTriangleCellData(indices, weights1); roads.AddTriangleCellData(indices, weights1); } else { TriangulateRoadEdge(center, mL, mR, index); } } 

यह सभी संकलक त्रुटियों को ठीक करने के लिए TriangulateRoad, TriangulateRoadEdgeऔर TriangulateRoadSegment, आवश्यक विधि तर्क जोड़ने के लिए बनी हुई है ।

  void TriangulateWithoutRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { TriangulateEdgeFan(center, e, cell.Index); if (cell.HasRoads) { Vector2 interpolators = GetRoadInterpolators(direction, cell); TriangulateRoad( center, Vector3.Lerp(center, e.v1, interpolators.x), Vector3.Lerp(center, e.v5, interpolators.y), e, cell.HasRoadThroughEdge(direction), cell.Index ); } } … void TriangulateRoadAdjacentToRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { … TriangulateRoad(roadCenter, mL, mR, e, hasRoadThroughEdge, cell.Index); if (previousHasRiver) { TriangulateRoadEdge(roadCenter, center, mL, cell.Index); } if (nextHasRiver) { TriangulateRoadEdge(roadCenter, mR, center, cell.Index); } } … void TriangulateEdgeStrip ( … ) { … if (hasRoad) { TriangulateRoadSegment( e1.v2, e1.v3, e1.v4, e2.v2, e2.v3, e2.v4, w1, w2, indices ); } } 

अब मेष डेटा सही है, और हम रोड शेडर पर आगे बढ़ेंगे । यह एक शीर्ष कार्यक्रम की जरूरत है और इसमें HexCellData होना चाहिए ।

  #pragma surface surf Standard fullforwardshadows decal:blend vertex:vert #pragma target 3.0 #include "HexCellData.cginc" 

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

  struct Input { float2 uv_MainTex; float3 worldPos; float visibility; }; 

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

  void vert (inout appdata_full v, out Input data) { UNITY_INITIALIZE_OUTPUT(Input, data); float4 cell0 = GetCellData(v, 0); float4 cell1 = GetCellData(v, 1); data.visibility = cell0.x * v.color.x + cell1.x * v.color.y; data.visibility = lerp(0.25, 1, data.visibility); } 

टुकड़े के कार्यक्रम में, हमें केवल रंग में दृश्यता जोड़ने की आवश्यकता है।

  void surf (Input IN, inout SurfaceOutputStandard o) { float4 noise = tex2D(_MainTex, IN.worldPos.xz * 0.025); fixed4 c = _Color * ((noise.y * 0.75 + 0.25) * IN.visibility); … } 

दृश्यता के साथ सड़कें।

खुला पानी

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

  void TriangulateOpenWater ( HexDirection direction, HexCell cell, HexCell neighbor, Vector3 center ) { … water.AddTriangle(center, c1, c2); Vector3 indices; indices.x = indices.y = indices.z = cell.Index; water.AddTriangleCellData(indices, weights1); if (direction <= HexDirection.SE && neighbor != null) { … water.AddQuad(c1, c2, e1, e2); indices.y = neighbor.Index; water.AddQuadCellData(indices, weights1, weights2); if (direction <= HexDirection.E) { … water.AddTriangle( c2, e2, c2 + HexMetrics.GetWaterBridge(direction.Next()) ); indices.z = nextNeighbor.Index; water.AddTriangleCellData( indices, weights1, weights2, weights3 ); } } } 

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

  void TriangulateWaterShore ( HexDirection direction, HexCell cell, HexCell neighbor, Vector3 center ) { … water.AddTriangle(center, e1.v1, e1.v2); water.AddTriangle(center, e1.v2, e1.v3); water.AddTriangle(center, e1.v3, e1.v4); water.AddTriangle(center, e1.v4, e1.v5); Vector3 indices; indices.x = indices.y = indices.z = cell.Index; water.AddTriangleCellData(indices, weights1); water.AddTriangleCellData(indices, weights1); water.AddTriangleCellData(indices, weights1); water.AddTriangleCellData(indices, weights1); … } 

वाटर शेड को रोड शेडर के समान ही बदलने की आवश्यकता है , लेकिन इसे दो नहीं, बल्कि तीन कोशिकाओं की दृश्यता को मिलाने की जरूरत है।

  #pragma surface surf Standard alpha vertex:vert #pragma target 3.0 #include "Water.cginc" #include "HexCellData.cginc" sampler2D _MainTex; struct Input { float2 uv_MainTex; float3 worldPos; float visibility; }; … void vert (inout appdata_full v, out Input data) { UNITY_INITIALIZE_OUTPUT(Input, data); float4 cell0 = GetCellData(v, 0); float4 cell1 = GetCellData(v, 1); float4 cell2 = GetCellData(v, 2); data.visibility = cell0.x * v.color.x + cell1.x * v.color.y + cell2.x * v.color.z; data.visibility = lerp(0.25, 1, data.visibility); } void surf (Input IN, inout SurfaceOutputStandard o) { float waves = Waves(IN.worldPos.xz, _MainTex); fixed4 c = saturate(_Color + waves); o.Albedo = c.rgb * IN.visibility; … } 

दृश्यता के साथ खुला पानी।

तट और मुहाना

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

  Vector3 indices; // indices.x = indices.y = indices.z = cell.Index; indices.x = indices.z = cell.Index; indices.y = neighbor.Index; 

सेल डेटा को क्वाड्स और तट के त्रिकोण में जोड़ें। हम कॉल पर इंडेक्स भी पास करते हैं TriangulateEstuary।

  if (cell.HasRiverThroughEdge(direction)) { TriangulateEstuary( e1, e2, cell.IncomingRiver == direction, indices ); } else { … waterShore.AddQuadUV(0f, 0f, 0f, 1f); waterShore.AddQuadCellData(indices, weights1, weights2); waterShore.AddQuadCellData(indices, weights1, weights2); waterShore.AddQuadCellData(indices, weights1, weights2); waterShore.AddQuadCellData(indices, weights1, weights2); } HexCell nextNeighbor = cell.GetNeighbor(direction.Next()); if (nextNeighbor != null) { … waterShore.AddTriangleUV( … ); indices.z = nextNeighbor.Index; waterShore.AddTriangleCellData( indices, weights1, weights2, weights3 ); } 

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

  void TriangulateEstuary ( EdgeVertices e1, EdgeVertices e2, bool incomingRiver, Vector3 indices ) { waterShore.AddTriangle(e2.v1, e1.v2, e1.v1); waterShore.AddTriangle(e2.v5, e1.v5, e1.v4); waterShore.AddTriangleUV( new Vector2(0f, 1f), new Vector2(0f, 0f), new Vector2(0f, 0f) ); waterShore.AddTriangleUV( new Vector2(0f, 1f), new Vector2(0f, 0f), new Vector2(0f, 0f) ); waterShore.AddTriangleCellData(indices, weights2, weights1, weights1); waterShore.AddTriangleCellData(indices, weights2, weights1, weights1); estuaries.AddQuad(e2.v1, e1.v2, e2.v2, e1.v3); estuaries.AddTriangle(e1.v3, e2.v2, e2.v4); estuaries.AddQuad(e1.v3, e1.v4, e2.v4, e2.v5); estuaries.AddQuadUV( new Vector2(0f, 1f), new Vector2(0f, 0f), new Vector2(1f, 1f), new Vector2(0f, 0f) ); estuaries.AddTriangleUV( new Vector2(0f, 0f), new Vector2(1f, 1f), new Vector2(1f, 1f) ); estuaries.AddQuadUV( new Vector2(0f, 0f), new Vector2(0f, 0f), new Vector2(1f, 1f), new Vector2(0f, 1f) ); estuaries.AddQuadCellData( indices, weights2, weights1, weights2, weights1 ); estuaries.AddTriangleCellData(indices, weights1, weights2, weights2); estuaries.AddQuadCellData(indices, weights1, weights2); … } 

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

  #pragma surface surf Standard alpha vertex:vert #pragma target 3.0 #include "Water.cginc" #include "HexCellData.cginc" sampler2D _MainTex; struct Input { float2 uv_MainTex; float3 worldPos; float visibility; }; … void vert (inout appdata_full v, out Input data) { UNITY_INITIALIZE_OUTPUT(Input, data); float4 cell0 = GetCellData(v, 0); float4 cell1 = GetCellData(v, 1); float4 cell2 = GetCellData(v, 2); data.visibility = cell0.x * v.color.x + cell1.x * v.color.y + cell2.x * v.color.z; data.visibility = lerp(0.25, 1, data.visibility); } void surf (Input IN, inout SurfaceOutputStandard o) { … fixed4 c = saturate(_Color + max(foam, waves)); o.Albedo = c.rgb * IN.visibility; … } 

Scheider नदी के मुहाने दो कोशिकाओं के घोला जा सकता है दृश्यता, साथ ही शेडर रोड जनरल विवरण । उसके पास पहले से ही एक शीर्ष कार्यक्रम है, क्योंकि हमें नदियों के यूवी-निर्देशांक को प्रसारित करने की आवश्यकता है।

  #include "Water.cginc" #include "HexCellData.cginc" sampler2D _MainTex; struct Input { float2 uv_MainTex; float2 riverUV; float3 worldPos; float visibility; }; half _Glossiness; half _Metallic; fixed4 _Color; void vert (inout appdata_full v, out Input o) { UNITY_INITIALIZE_OUTPUT(Input, o); o.riverUV = v.texcoord1.xy; float4 cell0 = GetCellData(v, 0); float4 cell1 = GetCellData(v, 1); o.visibility = cell0.x * v.color.x + cell1.x * v.color.y; o.visibility = lerp(0.25, 1, o.visibility); } void surf (Input IN, inout SurfaceOutputStandard o) { … fixed4 c = saturate(_Color + water); o.Albedo = c.rgb * IN.visibility; … } 

दृश्यता के साथ तट और मुहाना।

नदी

नदियों के साथ काम करने वाले अंतिम जल क्षेत्र हैं। HexGridChunk.TriangulateRiverQuadपैरामीटर में एक इंडेक्स वेक्टर जोड़ें और इसे मेष में जोड़ें ताकि यह दो कोशिकाओं की दृश्यता को बनाए रख सके।

  void TriangulateRiverQuad ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, float y, float v, bool reversed, Vector3 indices ) { TriangulateRiverQuad(v1, v2, v3, v4, y, y, v, reversed, indices); } void TriangulateRiverQuad ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, float y1, float y2, float v, bool reversed, Vector3 indices ) { … rivers.AddQuadCellData(indices, weights1, weights2); } 

TriangulateWithRiverBeginOrEndसेल के केंद्र में एक क्वाड और एक त्रिकोण के साथ नदी समापन बिंदु बनाता है। इसके लिए आवश्यक सेल डेटा जोड़ें।

  void TriangulateWithRiverBeginOrEnd ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { … if (!cell.IsUnderwater) { bool reversed = cell.HasIncomingRiver; Vector3 indices; indices.x = indices.y = indices.z = cell.Index; TriangulateRiverQuad( m.v2, m.v4, e.v2, e.v4, cell.RiverSurfaceY, 0.6f, reversed, indices ); center.y = m.v2.y = m.v4.y = cell.RiverSurfaceY; rivers.AddTriangle(center, m.v2, m.v4); … rivers.AddTriangleCellData(indices, weights1); } } 

हम पहले से ही इन सेल सूचकांकों में हैं TriangulateWithRiver, इसलिए हम उन्हें कॉल पर पास करते हैं TriangulateRiverQuad।

  void TriangulateWithRiver ( HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e ) { … if (!cell.IsUnderwater) { bool reversed = cell.IncomingRiver == direction; TriangulateRiverQuad( centerL, centerR, m.v2, m.v4, cell.RiverSurfaceY, 0.4f, reversed, indices ); TriangulateRiverQuad( m.v2, m.v4, e.v2, e.v4, cell.RiverSurfaceY, 0.6f, reversed, indices ); } } 

हम उन झरनों में सूचकांक समर्थन भी जोड़ते हैं जो गहरे पानी में डालते हैं।

  void TriangulateWaterfallInWater ( Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, float y1, float y2, float waterY, Vector3 indices ) { … rivers.AddQuadCellData(indices, weights1, weights2); } 

और अंत में, इसे बदल दें TriangulateConnectionताकि यह नदियों और झरनों की विधियों के लिए आवश्यक अनुक्रमित हो जाए।

  void TriangulateConnection ( HexDirection direction, HexCell cell, EdgeVertices e1 ) { … if (hasRiver) { e2.v3.y = neighbor.StreamBedY; Vector3 indices; indices.x = indices.z = cell.Index; indices.y = neighbor.Index; if (!cell.IsUnderwater) { if (!neighbor.IsUnderwater) { TriangulateRiverQuad( e1.v2, e1.v4, e2.v2, e2.v4, cell.RiverSurfaceY, neighbor.RiverSurfaceY, 0.8f, cell.HasIncomingRiver && cell.IncomingRiver == direction, indices ); } else if (cell.Elevation > neighbor.WaterLevel) { TriangulateWaterfallInWater( e1.v2, e1.v4, e2.v2, e2.v4, cell.RiverSurfaceY, neighbor.RiverSurfaceY, neighbor.WaterSurfaceY, indices ); } } else if ( !neighbor.IsUnderwater && neighbor.Elevation > cell.WaterLevel ) { TriangulateWaterfallInWater( e2.v4, e2.v2, e1.v4, e1.v2, neighbor.RiverSurfaceY, cell.RiverSurfaceY, cell.WaterSurfaceY, indices ); } } … } 

रिवर शैडर को रोड शैडर के समान परिवर्तन करने की आवश्यकता है ।

  #pragma surface surf Standard alpha vertex:vert #pragma target 3.0 #include "Water.cginc" #include "HexCellData.cginc" sampler2D _MainTex; struct Input { float2 uv_MainTex; float visibility; }; … void vert (inout appdata_full v, out Input data) { UNITY_INITIALIZE_OUTPUT(Input, data); float4 cell0 = GetCellData(v, 0); float4 cell1 = GetCellData(v, 1); data.visibility = cell0.x * v.color.x + cell1.x * v.color.y; data.visibility = lerp(0.25, 1, data.visibility); } void surf (Input IN, inout SurfaceOutputStandard o) { float river = River(IN.uv_MainTex, _MainTex); fixed4 c = saturate(_Color + river); o.Albedo = c.rgb * IN.visibility; … } 

दृश्यता के साथ नदियाँ।

unitypackage

वस्तुओं और दृश्यता

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

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

हम पहले से ही स्थलाकृति पर ग्रिड को प्रोजेक्ट करने के लिए एक हेक्सागोनल पैटर्न के साथ एक बनावट का उपयोग कर रहे हैं। यह बनावट 2 × 2 के सेल क्षेत्र को परिभाषित करती है। इसलिए, हम आसानी से गणना कर सकते हैं कि हम किस क्षेत्र में हैं। उसके बाद, आप इस क्षेत्र में कोशिकाओं के लिए X और Z ऑफसेट युक्त बनावट लागू कर सकते हैं और इस डेटा का उपयोग उस सेल की गणना करने के लिए कर सकते हैं जिसमें हम स्थित हैं।

यहाँ एक समान बनावट है। X ऑफसेट को उसके लाल चैनल में संग्रहीत किया जाता है, और Z ऑफसेट को ग्रीन चैनल में संग्रहीत किया जाता है। चूंकि यह 2 × 2 कोशिकाओं के क्षेत्र को कवर करता है, हमें 0 और 2 से ऑफसेट की आवश्यकता होती है। इस तरह के डेटा को रंगीन चैनल में संग्रहीत नहीं किया जा सकता है, इसलिए ऑफसेट आधे से कम हो जाते हैं। हमें कोशिकाओं के स्पष्ट किनारों की आवश्यकता नहीं है, इसलिए एक छोटी सी बनावट पर्याप्त है।


ग्रिड की बनावट समन्वय करती है।

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


बनावट आयात विकल्प।

दृश्यता के साथ ऑब्जेक्ट शैडर

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

 Shader "Custom/Feature" { 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 [NoTilingOffset] _GridCoordinates ("Grid Coordinates", 2D) = "white" {} } SubShader { Tags { "RenderType"="Opaque" } LOD 200 CGPROGRAM #pragma surface surf Standard fullforwardshadows vertex:vert #pragma target 3.0 #include "../HexCellData.cginc" sampler2D _MainTex, _GridCoordinates; half _Glossiness; half _Metallic; fixed4 _Color; struct Input { float2 uv_MainTex; float visibility; }; void vert (inout appdata_full v, out Input data) { UNITY_INITIALIZE_OUTPUT(Input, data); float3 pos = mul(unity_ObjectToWorld, v.vertex); data.visibility = 1; } void surf (Input IN, inout SurfaceOutputStandard o) { fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color; o.Albedo = c.rgb * IN.visibility; o.Metallic = _Metallic; o.Smoothness = _Glossiness; o.Alpha = ca; } ENDCG } FallBack "Diffuse" } 

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


मेष बनावट के साथ शहरी।

सेल डेटा तक पहुँचें

शीर्ष कार्यक्रम में ग्रिड निर्देशांक की बनावट का नमूना लेने के लिए, हमें फिर से tex2Dlodचार-घटक बनावट समन्वय वेक्टर की आवश्यकता है। पहले दो निर्देशांक XZ दुनिया की स्थिति हैं। अन्य दो पहले की तरह शून्य के बराबर हैं।

  void vert (inout appdata_full v, out Input data) { UNITY_INITIALIZE_OUTPUT(Input, data); float3 pos = mul(unity_ObjectToWorld, v.vertex); float4 gridUV = float4(pos.xz, 0, 0); data.visibility = 1; } 

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

  float4 gridUV = float4(pos.xz, 0, 0); gridUV.x *= 1 / (4 * 8.66025404); gridUV.y *= 1 / (2 * 15.0); 

हम यह पता लगा सकते हैं कि 2 × 2 कोशिकाओं के किस भाग में हम यूवी निर्देशांक के मान को नीचे ले जा रहे हैं। यह कोशिकाओं के निर्देशांक के लिए आधार बनाता है।

  float4 gridUV = float4(pos.xz, 0, 0); gridUV.x *= 1 / (4 * 8.66025404); gridUV.y *= 1 / (2 * 15.0); float2 cellDataCoordinates = floor(gridUV.xy); 

उस कक्ष के निर्देशांक खोजने के लिए जिसमें हम हैं, हम बनावट में संग्रहीत विस्थापन को जोड़ते हैं।

  float2 cellDataCoordinates = floor(gridUV.xy) + tex2Dlod(_GridCoordinates, gridUV).rg; 

चूंकि ग्रिड का हिस्सा आकार में 2 × 2 है, और ऑफसेट को आधा कर दिया गया है, हमें अंतिम निर्देशांक प्राप्त करने के लिए परिणाम को दोगुना करने की आवश्यकता है।

  float2 cellDataCoordinates = floor(gridUV.xy) + tex2Dlod(_GridCoordinates, gridUV).rg; cellDataCoordinates *= 2; 

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

 float4 GetCellData (float2 cellDataCoordinates) { float2 uv = cellDataCoordinates + 0.5; uv.x *= _HexCellData_TexelSize.x; uv.y *= _HexCellData_TexelSize.y; return tex2Dlod(_HexCellData, float4(uv, 0, 0)); } 

अब हम शीर्ष शेडर कार्यक्रम में इसका उपयोग कर सकते फ़ीचर ।

  cellDataCoordinates *= 2; data.visibility = GetCellData(cellDataCoordinates).x; data.visibility = lerp(0.25, 1, data.visibility); 

दृश्यता वाली वस्तुएं।

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


दृश्यता बदलने वाली दीवारें।

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

unitypackage

भाग 21: मानचित्र अनुसंधान

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

पिछले भाग में, हमने युद्ध का कोहरा जोड़ा, जिसे अब हम मानचित्र अनुसंधान को लागू करने के लिए परिष्कृत करेंगे।


हम दुनिया का पता लगाने के लिए तैयार हैं।

सम्पूर्ण मानचित्र को संपादन मोड में प्रदर्शित करें

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

दृश्यता स्विचिंग

हम नियंत्रित कर सकते हैं कि क्या शेडर्स कीवर्ड का उपयोग करके दृश्यता का उपयोग करते हैं, जैसा कि ग्रिड पर ओवरले के साथ किया गया था। संपादन मोड की स्थिति को दर्शाने के लिए HEX_MAP_EDIT_MODE कीवर्ड का उपयोग करें। चूँकि कई shaders को इस कीवर्ड के बारे में पता होना चाहिए, हम स्थैतिक तरीकों Shader.EnableKeyWordऔर का उपयोग करके इसे विश्व स्तर पर परिभाषित करेंगे Shader.DisableKeyword। हम HexGameUI.SetEditModeसंपादन मोड को बदलते समय उचित विधि को कॉल करेंगे ।

  public void SetEditMode (bool toggle) { enabled = !toggle; grid.ShowUI(!toggle); grid.ClearPath(); if (toggle) { Shader.EnableKeyword("HEX_MAP_EDIT_MODE"); } else { Shader.DisableKeyword("HEX_MAP_EDIT_MODE"); } } 

मोड शेड संपादित करें

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

 sampler2D _HexCellData; float4 _HexCellData_TexelSize; float4 FilterCellData (float4 data) { #if defined(HEX_MAP_EDIT_MODE) data.x = 1; #endif return data; } 

हम इस फ़ंक्शन से गुजरते हैं, GetCellDataइसे वापस करने से पहले दोनों फ़ंक्शन का परिणाम ।

 float4 GetCellData (appdata_full v, int index) { … return FilterCellData(data); } float4 GetCellData (float2 cellDataCoordinates) { … return FilterCellData(tex2Dlod(_HexCellData, float4(uv, 0, 0))); } 

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

  #pragma multi_compile _ HEX_MAP_EDIT_MODE 

अब, जब मानचित्र संपादन मोड पर स्विच किया जाएगा, तो युद्ध का कोहरा गायब हो जाएगा।

unitypackage

कोशिका अनुसंधान

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

ट्रैकिंग अध्ययन की स्थिति

पढ़ाई की स्थिति की निगरानी के लिए समर्थन जोड़ने के लिए, हम HexCellसामान्य संपत्ति में जोड़ते हैं IsExplored।

  public bool IsExplored { get; set; } 

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

  public bool IsExplored { get; private set; } 

पहली बार जब सेल की दृश्यता शून्य से अधिक हो जाती है, तो सेल को जांच माना जाने लगता है, और इसलिए IsExploredएक मान असाइन किया जाना चाहिए true। वास्तव में, यह हमारे लिए पर्याप्त होगा कि हम सेल की जांच करें जब दृश्यता बढ़ जाती है। 1. यह कॉल करने से पहले किया जाना चाहिए RefreshVisibility।

  public void IncreaseVisibility () { visibility += 1; if (visibility == 1) { IsExplored = true; ShaderData.RefreshVisibility(this); } } 

स्थानांतरण के लिए अनुसंधान की स्थिति

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

  public void RefreshVisibility (HexCell cell) { int index = cell.Index; cellTextureData[index].r = cell.IsVisible ? (byte)255 : (byte)0; cellTextureData[index].g = cell.IsExplored ? (byte)255 : (byte)0; enabled = true; } 

काली अस्पष्टीकृत राहत

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

 float4 FilterCellData (float4 data) { #if defined(HEX_MAP_EDIT_MODE) data.xy = 1; #endif return data; } 

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

  struct Input { float4 color : COLOR; float3 worldPos; float3 terrain; float4 visibility; }; 

अब, शीर्ष कार्यक्रम में, जब हम दृश्यता सूचकांक बदलते हैं, तो हमें स्पष्ट रूप से पहुंच प्राप्त करनी चाहिए data.visibility.xyz।

  void vert (inout appdata_full v, out Input data) { … data.visibility.xyz = lerp(0.25, 1, data.visibility.xyz); } 

उसके बाद, हम अध्ययन के राज्यों को जोड़ते हैं और परिणाम लिखते हैं data.visibility.w। यह अन्य शेड्स में दृश्यता के संयोजन के समान है, लेकिन इन कोशिकाओं के घटक Y का उपयोग कर रहा है।

  data.visibility.xyz = lerp(0.25, 1, data.visibility.xyz); data.visibility.w = cell0.y * v.color.x + cell1.y * v.color.y + cell2.y * v.color.z; 

शोध की स्थिति अब खंड कार्यक्रम के माध्यम से उपलब्ध है IN.visibility.w। अल्बेडो की गणना में इस पर विचार करें।

  void surf (Input IN, inout SurfaceOutputStandard o) { … float explored = IN.visibility.w; o.Albedo = c.rgb * grid * _Color * explored; o.Metallic = _Metallic; o.Smoothness = _Glossiness; o.Alpha = ca; } 

अस्पष्टीकृत स्थलाकृति अब काली है।

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

बचत और लोडिंग अनुसंधान की स्थिति

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

  const int mapFileVersion = 3; 

फ़ाइल संस्करण को लिखते Saveसमय और फ़ाइल समर्थन को चेक करते समय हम इस निरंतर का उपयोग करेंगे Load।

  void Save (string path) { using ( BinaryWriter writer = new BinaryWriter(File.Open(path, FileMode.Create)) ) { writer.Write(mapFileVersion); hexGrid.Save(writer); } } void Load (string path) { if (!File.Exists(path)) { Debug.LogError("File does not exist " + path); return; } using (BinaryReader reader = new BinaryReader(File.OpenRead(path))) { int header = reader.ReadInt32(); if (header <= mapFileVersion) { hexGrid.Load(reader, header); HexMapCamera.ValidatePosition(); } else { Debug.LogWarning("Unknown map format " + header); } } } 

अंतिम चरण के रूप में, HexCell.Saveहम अध्ययन की स्थिति को रिकॉर्ड करते हैं।

  public void Save (BinaryWriter writer) { … writer.Write(IsExplored); } 

और हम इसे अंत में पढ़ेंगे Load। उसके बाद, हम RefreshVisibilityअध्ययन की स्थिति को पिछले एक से अलग करते हैं।

  public void Load (BinaryReader reader) { … IsExplored = reader.ReadBoolean(); ShaderData.RefreshVisibility(this); } 

पुरानी सेव फाइल्स के साथ बैकवर्ड कम्पैटिबिलिटी बनाए रखने के लिए, हमें सेव स्टेट को पढ़ना छोड़ना होगा अगर फाइल वर्जन 3 से कम है। इस मामले में, डिफ़ॉल्ट रूप से, सेल में स्टेट "अनएक्सप्लेयर्ड" होगा। ऐसा करने के लिए, हमें Loadहेडर डेटा को एक पैरामीटर के रूप में जोड़ना होगा ।

  public void Load (BinaryReader reader, int header) { … IsExplored = header >= 3 ? reader.ReadBoolean() : false; ShaderData.RefreshVisibility(this); } 

अब HexGrid.Loadइसे HexCell.Loadहेडर डेटा में पास करना होगा ।

  public void Load (BinaryReader reader, int header) { … for (int i = 0; i < cells.Length; i++) { cells[i].Load(reader, header); } … } 

अब, नक्शे सहेजते और लोड करते समय, कोशिकाओं की खोज की स्थिति को ध्यान में रखा जाएगा।

unitypackage

अज्ञात कोशिकाओं को छिपाएं

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

जिससे राहत वाकई में काली हो जाए

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

रंग संपत्ति की जगह _Metallic संपत्ति पर _Specular । डिफ़ॉल्ट रूप से, इसका रंग मान (0.2, 0.2, 0.2) के बराबर होना चाहिए। इसलिए हम गारंटी देते हैं कि यह धातुई संस्करण की उपस्थिति से मेल खाएगा।

  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 // _Metallic ("Metallic", Range(0,1)) = 0.0 _Specular ("Specular", Color) = (0.2, 0.2, 0.2) } 

इसके अलावा संबंधित shader चर बदलें। स्पेक्युलर सरफेस शेड्स के रंग को परिभाषित किया गया है fixed3, इसलिए इसका उपयोग करते हैं।

  half _Glossiness; // half _Metallic; fixed3 _Specular; fixed4 _Color; 

साथ pragma सतह सर्फ बदलें स्टैंडर्ड पर StandardSpecular । यह यूनिटी को स्पेक्युलर का उपयोग करके शेड बनाने के लिए मजबूर करेगा।

  #pragma surface surf StandardSpecular fullforwardshadows vertex:vert 

अब फ़ंक्शन surfको दूसरे पैरामीटर के प्रकार की आवश्यकता है SurfaceOutputStandardSpecular। इसके अलावा, अब आपको मूल्य नहीं o.Metallic, बल्कि असाइन करना होगा o.Specular।

  void surf (Input IN, inout SurfaceOutputStandardSpecular o) { … float explored = IN.visibility.w; o.Albedo = c.rgb * grid * _Color * explored; // o.Metallic = _Metallic; o.Specular = _Specular; o.Smoothness = _Glossiness; o.Alpha = ca; } 

अब हम exploredस्पेक्युलर रंग पर विचार करके हाइलाइट्स को अस्पष्ट कर सकते हैं ।

  o.Specular = _Specular * explored; 

परिलक्षित प्रकाश के बिना अस्पष्टीकृत इलाका।

जैसा कि आप तस्वीर में देख सकते हैं, अब अस्पष्टीकृत राहत सुस्त काली दिखती है। हालांकि, जब एक स्पर्शरेखा कोण से देखा जाता है, तो सतह एक दर्पण में बदल जाती है, जिसके कारण राहत पर्यावरण को प्रतिबिंबित करना शुरू कर देती है, अर्थात, स्काईबॉक्स।



अस्पष्टीकृत क्षेत्र अभी भी पर्यावरण को दर्शाते हैं।

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

  float explored = IN.visibility.w; o.Albedo = c.rgb * grid * _Color * explored; o.Specular = _Specular * explored; o.Smoothness = _Glossiness; o.Occlusion = explored; o.Alpha = ca; 

बिना प्रतिबिंब के अस्पष्टीकृत।

मैचिंग बैकग्राउंड

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

  Properties { … _BackgroundColor ("Background Color", Color) = (0,0,0) } … half _Glossiness; fixed3 _Specular; fixed4 _Color; half3 _BackgroundColor; 

इस रंग का उपयोग करने के लिए, हम इसे प्रकाश के रूप में जोड़ेंगे। यह o.Emissionएक माइनस द्वारा खोजे गए बैकग्राउंड कलर वैल्यू को गुणा करके पूरा किया जाता है।

  o.Occlusion = explored; o.Emission = _BackgroundColor * (1 - explored); 

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


ग्रे पृष्ठभूमि रंग के साथ राहत सामग्री।

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


एक समान पृष्ठभूमि रंग के साथ कैमरा।


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


अस्पष्टीकृत कोशिकाएं अब दिखाई नहीं देती हैं।

राहत वस्तुओं को छिपाएं

अब हमारे पास केवल राहत की जाली है। अध्ययन की बाकी स्थिति अभी तक प्रभावित नहीं हुई है।


अभी तक केवल राहत छिपी है।

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

  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 _Specular ("Specular", Color) = (0.2, 0.2, 0.2) _BackgroundColor ("Background Color", Color) = (0,0,0) [NoScaleOffset] _GridCoordinates ("Grid Coordinates", 2D) = "white" {} } 

पहले की तरह आगे की सतह और चर।

  #pragma surface surf StandardSpecular fullforwardshadows vertex:vert … half _Glossiness; // half _Metallic; fixed3 _Specular; fixed4 _Color; half3 _BackgroundColor; 

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

  struct Input { float2 uv_MainTex; float2 visibility; }; 

इसे बदल दें vertताकि यह दृश्यता डेटा के लिए स्पष्ट रूप से उपयोग हो data.visibility.x, और फिर data.visibility.yअध्ययन डेटा के मूल्य को असाइन करें ।

  void vert (inout appdata_full v, out Input data) { … float4 cellData = GetCellData(cellDataCoordinates); data.visibility.x = cellData.x; data.visibility.x = lerp(0.25, 1, data.visibility.x); data.visibility.y = cellData.y; } 

इसे बदल दें surfताकि यह टेरेन की तरह नए डेटा का उपयोग करे ।

  void surf (Input IN, inout SurfaceOutputStandardSpecular o) { fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color; float explored = IN.visibility.y; o.Albedo = c.rgb * (IN.visibility.x * explored); // o.Metallic = _Metallic; o.Specular = _Specular * explored; o.Smoothness = _Glossiness; o.Occlusion = explored; o.Emission = _BackgroundColor * (1 - explored); o.Alpha = ca; } 

छिपी हुई राहत की वस्तु।

पानी छिपाओ

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

रूपांतरण के बाद, visibilityएक और घटक जोड़ें और उसके अनुसार इसे बदलें vert। दोनों शेड तीन कोशिकाओं के डेटा को मिलाते हैं।

  struct Input { … float2 visibility; }; … void vert (inout appdata_full v, out Input data) { … data.visibility.x = cell0.x * v.color.x + cell1.x * v.color.y + cell2.x * v.color.z; data.visibility.x = lerp(0.25, 1, data.visibility.x); data.visibility.y = cell0.y * v.color.x + cell1.y * v.color.y + cell2.y * v.color.z; } 

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

  void surf (Input IN, inout SurfaceOutputStandardSpecular o) { … float explored = IN.visibility.y; o.Albedo = c.rgb * IN.visibility.x; o.Specular = _Specular * explored; o.Smoothness = _Glossiness; o.Occlusion = explored; o.Alpha = ca * explored; } 

छिपा हुआ पानी।

हम नदियों, नदियों और सड़कों को छिपाते हैं

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

  struct Input { … float2 visibility; }; … void vert (inout appdata_full v, out Input data) { … data.visibility.x = cell0.x * v.color.x + cell1.x * v.color.y; data.visibility.x = lerp(0.25, 1, data.visibility.x); data.visibility.y = cell0.y * v.color.x + cell1.y * v.color.y; } 

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

  void surf (Input IN, inout SurfaceOutputStandardSpecular o) { … float explored = IN.visibility.y; fixed4 c = saturate(_Color + water); o.Albedo = c.rgb * IN.visibility.x; o.Specular = _Specular * explored; o.Smoothness = _Glossiness; o.Occlusion = explored; o.Alpha = ca * explored; } 

Shader रोड थोड़ा अलग है क्योंकि इसमें एक अतिरिक्त सम्मिश्रण मीट्रिक का उपयोग किया जाता है।

  void surf (Input IN, inout SurfaceOutputStandardSpecular o) { float4 noise = tex2D(_MainTex, IN.worldPos.xz * 0.025); fixed4 c = _Color * ((noise.y * 0.75 + 0.25) * IN.visibility.x); float blend = IN.uv_MainTex.x; blend *= noise.x + 0.5; blend = smoothstep(0.4, 0.7, blend); float explored = IN.visibility.y; o.Albedo = c.rgb; o.Specular = _Specular * explored; o.Smoothness = _Glossiness; o.Occlusion = explored; o.Alpha = blend * explored; } 

सब छिपा है।

unitypackage

अस्पष्टीकृत कोशिकाओं से बचना

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


अस्पष्टीकृत कोशिकाओं को नेविगेट करें।

स्क्वाड चलती की लागत निर्धारित करते हैं

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

करने के लिए HexUnitसामान्य विधि में जोड़ें GetMoveCost। उसे यह जानने की जरूरत है कि कौन सी कोशिकाएं उनके बीच चलती हैं, साथ ही दिशा भी। हम HexGrid.Searchइस पद्धति से जाने की लागतों के लिए संबंधित कोड को कॉपी करते हैं और परिवर्तनशील नामों को बदलते हैं।

  public int GetMoveCost ( HexCell fromCell, HexCell toCell, HexDirection direction) { HexEdgeType edgeType = fromCell.GetEdgeType(toCell); if (edgeType == HexEdgeType.Cliff) { continue; } int moveCost; if (fromCell.HasRoadThroughEdge(direction)) { moveCost = 1; } else if (fromCell.Walled != toCell.Walled) { continue; } else { moveCost = edgeType == HexEdgeType.Flat ? 5 : 10; moveCost += toCell.UrbanLevel + toCell.FarmLevel + toCell.PlantLevel; } } 

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

  public int GetMoveCost ( HexCell fromCell, HexCell toCell, HexDirection direction) { HexEdgeType edgeType = fromCell.GetEdgeType(toCell); if (edgeType == HexEdgeType.Cliff) { return -1; } int moveCost; if (fromCell.HasRoadThroughEdge(direction)) { moveCost = 1; } else if (fromCell.Walled != toCell.Walled) { return -1; } else { moveCost = edgeType == HexEdgeType.Flat ? 5 : 10; moveCost += toCell.UrbanLevel + toCell.FarmLevel + toCell.PlantLevel; } return moveCost; } 

अब हमें यह जानना होगा कि रास्ता ढूंढते समय, न केवल गति, बल्कि चयनित इकाई भी। उसी के अनुसार बदलिए HexGameUI.DoPathFinding।

  void DoPathfinding () { if (UpdateCurrentCell()) { if (currentCell && selectedUnit.IsValidDestination(currentCell)) { grid.FindPath(selectedUnit.Location, currentCell, selectedUnit); } else { grid.ClearPath(); } } } 

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

  public int Speed { get { return 24; } } 

HexGridपरिवर्तन FindPath, और Searchइतना है कि वे हमारे नए दृष्टिकोण के साथ काम कर सकते हैं।

  public void FindPath (HexCell fromCell, HexCell toCell, HexUnit unit) { ClearPath(); currentPathFrom = fromCell; currentPathTo = toCell; currentPathExists = Search(fromCell, toCell, unit); ShowPath(unit.Speed); } bool Search (HexCell fromCell, HexCell toCell, HexUnit unit) { int speed = unit.Speed; … } 

अब हम Searchपुराने कोड को हटा देंगे जो निर्धारित करता है कि क्या अगले सेल में जाना संभव है और आगे बढ़ने की लागत क्या है। इसके बजाय, हम फोन करेंगे HexUnit.IsValidDestinationऔर HexUnit.GetMoveCost। अगर सेलिंग की लागत नकारात्मक है, तो हम सेल को छोड़ देंगे।

  for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = current.GetNeighbor(d); if ( neighbor == null || neighbor.SearchPhase > searchFrontierPhase ) { continue; } // if (neighbor.IsUnderwater || neighbor.Unit) { // continue; // } // HexEdgeType edgeType = current.GetEdgeType(neighbor); // if (edgeType == HexEdgeType.Cliff) { // continue; // } // int moveCost; // if (current.HasRoadThroughEdge(d)) { // moveCost = 1; // } // else if (current.Walled != neighbor.Walled) { // continue; // } // else { // moveCost = edgeType == HexEdgeType.Flat ? 5 : 10; // moveCost += neighbor.UrbanLevel + neighbor.FarmLevel + // neighbor.PlantLevel; // } if (!unit.IsValidDestination(neighbor)) { continue; } int moveCost = unit.GetMoveCost(current, neighbor, d); if (moveCost < 0) { continue; } int distance = current.Distance + moveCost; int turn = (distance - 1) / speed; if (turn > currentTurn) { distance = turn * speed + moveCost; } … } 

गैर-अधिकृत क्षेत्रों को बायपास करें

अस्पष्टीकृत कोशिकाओं से बचने के लिए, यह सुनिश्चित करने के लिए हमारे लिए पर्याप्त है कि हम HexUnit.IsValidDestinationजांच लें कि क्या सेल की जांच की गई है।

  public bool IsValidDestination (HexCell cell) { return cell.IsExplored && !cell.IsUnderwater && !cell.Unit; } 

अधिक इकाइयां अस्पष्टीकृत कोशिकाओं को प्राप्त करने में सक्षम नहीं होंगी।

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


unitypackage

भाग 22: बढ़ी हुई दृश्यता

• दृश्यता को धीरे-धीरे बदलें।
• गुंजाइश निर्धारित करने के लिए सेल की ऊंचाई का उपयोग करें।
• नक्शे के किनारे छिपाएँ।

मानचित्र अन्वेषण के लिए समर्थन जोड़कर, हम संगणना और गुंजाइश बदलावों में सुधार करेंगे।


आगे देखने के लिए, ऊपर चढ़ें।

दृश्यता परिवर्तन

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

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

  public bool ImmediateMode { get; set; } 

संक्रमण सेल ट्रैकिंग

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

 using System.Collections.Generic; using UnityEngine; public class HexCellShaderData : MonoBehaviour { Texture2D cellTexture; Color32[] cellTextureData; List<HexCell> transitioningCells = new List<HexCell>(); public bool ImmediateMode { get; set; } public void Initialize (int x, int z) { … transitioningCells.Clear(); enabled = true; } … } 

फिलहाल, हम RefreshVisibilityसीधे सेल डेटा सेट कर रहे हैं। यह तत्काल संक्रमण मोड के लिए अभी भी सही है, लेकिन जब इसे अक्षम किया जाता है, तो हमें संक्रमण कोशिकाओं की सूची में एक सेल जोड़ना होगा।

  public void RefreshVisibility (HexCell cell) { int index = cell.Index; if (ImmediateMode) { cellTextureData[index].r = cell.IsVisible ? (byte)255 : (byte)0; cellTextureData[index].g = cell.IsExplored ? (byte)255 : (byte)0; } else { transitioningCells.Add(cell); } enabled = true; } 

दृश्यता अब काम नहीं करती है, क्योंकि अभी के लिए, हम सूची में कोशिकाओं के साथ कुछ भी नहीं कर रहे हैं।

लूप में कोशिकाओं के माध्यम से लूप

इसी मानों को तुरंत 255 या 0 पर सेट करने के बजाय, हम इन मूल्यों को धीरे-धीरे बढ़ाएंगे / घटाएंगे। परिवर्तन की चिकनाई परिवर्तन की दर पर निर्भर करती है। यह बहुत तेज नहीं होना चाहिए और बहुत धीमा नहीं होना चाहिए। सुंदर बदलाव और खेल की सुविधा के बीच एक अच्छा समझौता एक सेकंड के भीतर बदलना है। आइए इसे बदलने के लिए इसे आसान बनाने के लिए एक निरंतरता निर्धारित करें।

  const float transitionSpeed = 255f; 

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

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

  void LateUpdate () { int delta = (int)(Time.deltaTime * transitionSpeed); cellTexture.SetPixels32(cellTextureData); cellTexture.Apply(); enabled = transitioningCells.Count > 0; } 

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

  int delta = (int)(Time.deltaTime * transitionSpeed); if (delta == 0) { delta = 1; } 

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

  int delta = (int)(Time.deltaTime * transitionSpeed); if (delta == 0) { delta = 1; } for (int i = 0; i < transitioningCells.Count; i++) { UpdateCellData(transitioningCells[i], delta); } 

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

  for (int i = 0; i < transitioningCells.Count; i++) { if (!UpdateCellData(transitioningCells[i], delta)) { transitioningCells.RemoveAt(i--); } } 

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

  if (!UpdateCellData(transitioningCells[i], delta)) { transitioningCells[i--] = transitioningCells[transitioningCells.Count - 1]; transitioningCells.RemoveAt(transitioningCells.Count - 1); } 

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

  bool UpdateCellData (HexCell cell, int delta) { int index = cell.Index; Color32 data = cellTextureData[index]; bool stillUpdating = false; cellTextureData[index] = data; return stillUpdating; } 

सेल डेटा को अद्यतन करना

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

  bool stillUpdating = false; if (cell.IsExplored && data.g < 255) { stillUpdating = true; } cellTextureData[index] = data; 

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

  if (cell.IsExplored && data.g < 255) { stillUpdating = true; int t = data.g + delta; data.g = (byte)t; } 

लेकिन रूपांतरण से पहले, आपको यह सुनिश्चित करने की आवश्यकता है कि मान 255 से अधिक न हो।

  int t = data.g + delta; data.g = t >= 255 ? (byte)255 : (byte)t; 

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

  if (cell.IsExplored && data.g < 255) { … } if (cell.IsVisible && data.r < 255) { stillUpdating = true; int t = data.r + delta; data.r = t >= 255 ? (byte)255 : (byte)t; } 

चूंकि सेल फिर से अदृश्य हो सकता है, हमें यह जांचने की आवश्यकता है कि क्या आर के मूल्य को कम करना आवश्यक है। ऐसा तब होता है जब सेल अदृश्य होता है, लेकिन आर शून्य से अधिक है।

  if (cell.IsVisible) { if (data.r < 255) { stillUpdating = true; int t = data.r + delta; data.r = t >= 255 ? (byte)255 : (byte)t; } } else if (data.r > 0) { stillUpdating = true; int t = data.r - delta; data.r = t < 0 ? (byte)0 : (byte)t; } 

अब यह UpdateCellDataतैयार और दृश्यता संक्रमण सही ढंग से किया जाता है।


दृश्यता परिवर्तन।

डुप्लिकेट संक्रमण तत्वों के खिलाफ सुरक्षा

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

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

  public void RefreshVisibility (HexCell cell) { int index = cell.Index; if (ImmediateMode) { cellTextureData[index].r = cell.IsVisible ? (byte)255 : (byte)0; cellTextureData[index].g = cell.IsExplored ? (byte)255 : (byte)0; } else if (cellTextureData[index].b != 255) { cellTextureData[index].b = 255; transitioningCells.Add(cell); } enabled = true; } 

काम करने के लिए, हमें सेल संक्रमण पूरा होने के बाद B का मान रीसेट करना होगा।

  bool UpdateCellData (HexCell cell, int delta) { … if (!stillUpdating) { data.b = 0; } cellTextureData[index] = data; return stillUpdating; } 

नकल के बिना संक्रमण।

तुरंत दृश्यता लोड हो रहा है

दृश्यता परिवर्तन अब हमेशा क्रमिक होते हैं, यहां तक ​​कि एक नक्शा लोड करते समय भी। यह अतार्किक है, क्योंकि मानचित्र उस स्थिति का वर्णन करता है जिसमें कोशिकाएँ पहले से ही दिखाई देती हैं, इसलिए यहाँ संक्रमण अनुचित है। इसके अलावा, एक बड़े मानचित्र के कई दृश्यमान कोशिकाओं के लिए संक्रमण करने से लोड होने के बाद खेल धीमा हो सकता है। इसलिए, कोशिकाओं और दस्तों को लोड करने से पहले, आइए HexGrid.Loadतुरंत संक्रमण मोड में जाएं।

  public void Load (BinaryReader reader, int header) { … cellShaderData.ImmediateMode = true; for (int i = 0; i < cells.Length; i++) { cells[i].Load(reader, header); } … } 

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

  public void Load (BinaryReader reader, int header) { … bool originalImmediateMode = cellShaderData.ImmediateMode; cellShaderData.ImmediateMode = true; … cellShaderData.ImmediateMode = originalImmediateMode; } 

unitypackage

ऊंचाई-निर्भर गुंजाइश

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

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


क्षितिज दृष्टिकोण की ऊंचाई पर निर्भर करता है।

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

समीक्षा के लिए ऊंचाई

दायरा निर्धारित करते समय ऊंचाई को ध्यान में रखने के लिए, हमें ऊंचाई जानने की आवश्यकता है। यह जमीन की सेल या पानी के आधार पर पानी की सामान्य ऊंचाई या स्तर होगा। आइए इसे HexCellसंपत्ति में जोड़ें ।

  public int ViewElevation { get { return elevation >= waterLevel ? elevation : waterLevel; } } 

लेकिन अगर ऊंचाई गुंजाइश को प्रभावित करती है, तो सेल की देखने की ऊंचाई में बदलाव के साथ, दृश्यता की स्थिति भी बदल सकती है। चूंकि सेल अवरुद्ध हो गया है या अब कई इकाइयों के दायरे को अवरुद्ध कर रहा है, इसलिए यह निर्धारित करना इतना आसान नहीं है कि क्या बदलने की आवश्यकता है। सेल स्वयं इस समस्या को हल करने में सक्षम नहीं होगा, इसलिए इसे स्थिति में बदलाव की सूचना दें HexCellShaderData। मान लीजिए कि आपके HexCellShaderDataपास इसके लिए एक तरीका है ViewElevationChanged। HexCell.Elevationयदि आवश्यक हो, तो हम इसे असाइनमेंट पर कहेंगे ।

  public int Elevation { get { return elevation; } set { if (elevation == value) { return; } int originalViewElevation = ViewElevation; elevation = value; if (ViewElevation != originalViewElevation) { ShaderData.ViewElevationChanged(); } … } } 

उसी के लिए जाता है WaterLevel।

  public int WaterLevel { get { return waterLevel; } set { if (waterLevel == value) { return; } int originalViewElevation = ViewElevation; waterLevel = value; if (ViewElevation != originalViewElevation) { ShaderData.ViewElevationChanged(); } ValidateRivers(); Refresh(); } } 

दृश्यता रीसेट करें

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

  bool needsVisibilityReset; … public void ViewElevationChanged () { needsVisibilityReset = true; enabled = true; } 

सभी कोशिकाओं के दृश्यमान मूल्यों को रीसेट करने के लिए, आपके पास उनकी पहुंच होनी चाहिए, जो आपके पास HexCellShaderDataनहीं है। तो आइए इस जिम्मेदारी को सौंपते हैं HexGrid। ऐसा करने के लिए, आपको HexCellShaderDataसंपत्ति में जोड़ना होगा , जो आपको ग्रिड को संदर्भित करने की अनुमति देता है। फिर हम LateUpdateरीसेट का अनुरोध करने के लिए इसका उपयोग कर सकते हैं ।

  public HexGrid Grid { get; set; } … void LateUpdate () { if (needsVisibilityReset) { needsVisibilityReset = false; Grid.ResetVisibility(); } … } 

चलो आगे बढ़ते हैं HexGrid: HexGrid.Awakeशेडर डेटा बनाने के बाद ग्रिड के लिए लिंक सेट करें ।

  void Awake () { HexMetrics.noiseSource = noiseSource; HexMetrics.InitializeHashGrid(seed); HexUnit.unitPrefab = unitPrefab; cellShaderData = gameObject.AddComponent<HexCellShaderData>(); cellShaderData.Grid = this; CreateMap(cellCountX, cellCountZ); } 

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

  public void ResetVisibility () { for (int i = 0; i < cells.Length; i++) { cells[i].ResetVisibility(); } } 

अब हमें HexCellविधि में जोड़ने की आवश्यकता है ResetVisibilty। यह बस दृश्यता को शून्य कर देगा और दृश्यता अद्यतन को ट्रिगर करेगा। यह तब किया जाना चाहिए जब सेल दृश्यता शून्य से अधिक हो।

  public void ResetVisibility () { if (visibility > 0) { visibility = 0; ShaderData.RefreshVisibility(this); } } 

सभी दृश्यता डेटा को रीसेट करने के बाद, HexGrid.ResetVisibilityउसे फिर से सभी स्क्वाड में दृश्यता लागू करनी चाहिए, जिसके लिए उसे प्रत्येक स्क्वाड का दायरा जानना होगा। मान लीजिए कि यह संपत्ति का उपयोग करके प्राप्त किया जा सकता है VisionRange।

  public void ResetVisibility () { for (int i = 0; i < cells.Length; i++) { cells[i].ResetVisibility(); } for (int i = 0; i < units.Count; i++) { HexUnit unit = units[i]; IncreaseVisibility(unit.Location, unit.VisionRange); } } 

इस काम के लिए, हम नाम बदलने HexUnit.visionRangeको फिर से शुरू करेंगे HexUnit.VisionRangeऔर इसे एक संपत्ति में बदल देंगे । जबकि इसे 3 का निरंतर मूल्य प्राप्त होगा, लेकिन भविष्य में यह बदल जाएगा।

  public int VisionRange { get { return 3; } } 

इसके कारण, दृश्यता डेटा रीसेट हो जाएगा और सेल देखने की ऊँचाई को बदलने के बाद सही रहेगा। लेकिन यह संभावना है कि हम प्ले मोड में गुंजाइश का निर्धारण करने और पुनर्मूल्यांकन चलाने के लिए नियमों को बदल देंगे। ताकि गुंजाइश स्वतंत्र रूप से बदल जाए, चलो एक रीसेट चलाते हैं HexGrid.OnEnableजब पुनर्संयोजन का पता लगाया जाता है।

  void OnEnable () { if (!HexMetrics.noiseSource) { … ResetVisibility(); } } 

अब आप स्कोप कोड को बदल सकते हैं और प्ले मोड में रहते हुए परिणाम देख सकते हैं।

क्षितिज का विस्तार

दायरे की गणना निर्धारित है HexGrid.GetVisibleCells। ताकि ऊंचाई गुंजाइश को प्रभावित करती है, हम बस fromCellप्रसारण क्षेत्र को अस्थायी रूप से पुनर्परिभाषित करके देखने की ऊंचाई का उपयोग कर सकते हैं। तो हम आसानी से जांच कर सकते हैं कि क्या यह काम करता है।

  List<HexCell> GetVisibleCells (HexCell fromCell, int range) { … range = fromCell.ViewElevation; fromCell.SearchPhase = searchFrontierPhase; fromCell.Distance = 0; searchFrontier.Enqueue(fromCell); … } 

एक दायरे के रूप में ऊंचाई का उपयोग करें।

दृश्यता में बाधाएं

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


दायरा हस्तक्षेप नहीं करता है।

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

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

  int distance = current.Distance + 1; if (distance + neighbor.ViewElevation > range) { continue; } 

उच्च कोशिकाएं दृश्य को अवरुद्ध करती हैं।

कोनों के आसपास न देखें

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

  HexCoordinates fromCoordinates = fromCell.coordinates; while (searchFrontier.Count > 0) { … for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { … int distance = current.Distance + 1; if (distance + neighbor.ViewElevation > range || distance > fromCoordinates.DistanceTo(neighbor.coordinates) ) { continue; } … } } 

हम केवल सबसे छोटे रास्तों का उपयोग करते हैं।

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

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

  range += fromCell.ViewElevation; 

कम बिंदु पर पूर्ण दृश्य के साथ देखें।

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


unitypackage

जिन कोशिकाओं को खोजा नहीं जा सकता है

दृश्यता के साथ अंतिम समस्या मानचित्र के किनारों की चिंता करती है। राहत अचानक और संक्रमण के बिना समाप्त हो जाती है, क्योंकि किनारे पर कोशिकाओं का कोई पड़ोसी नहीं है।


नक्शे के किनारे चिह्नित।

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

हम जांच के रूप में कोशिकाओं को चिह्नित करते हैं

यह इंगित करने के लिए कि एक सेल की जांच की जा सकती है, HexCellसंपत्ति में जोड़ें Explorable।

  public bool Explorable { get; set; } 

अब एक सेल दिखाई दे सकता है अगर यह एक जांच है, तो IsVisibleहम इसे खाते में लेने के लिए संपत्ति को बदल देंगे।

  public bool IsVisible { get { return visibility > 0 && Explorable; } } 

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

  public bool IsExplored { get { return explored && Explorable; } private set { explored = value; } } … bool explored; 

नक्शे के किनारे छिपाएँ

आप विधि में एक आयताकार मानचित्र के किनारे को छिपा सकते हैं HexGrid.CreateCell। सेल जो किनारे पर नहीं हैं, जांच की जाती है, बाकी सभी बेरोज़गार हैं।

  void CreateCell (int x, int z, int i) { … HexCell cell = cells[i] = Instantiate<HexCell>(cellPrefab); cell.transform.localPosition = position; cell.coordinates = HexCoordinates.FromOffsetCoordinates(x, z); cell.Index = i; cell.ShaderData = cellShaderData; cell.Explorable = x > 0 && z > 0 && x < cellCountX - 1 && z < cellCountZ - 1; … } 

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


नक्शे के अस्पष्टीकृत किनारे।

अस्पष्टीकृत कोशिकाएं दृश्यता में बाधा डालती हैं

अंत में, यदि सेल की जांच नहीं की जा सकती है, तो इसे दृश्यता में हस्तक्षेप करना चाहिए। HexGrid.GetVisibleCellsइसे ध्यान में रखते हुए बदलें ।

  if ( neighbor == null || neighbor.SearchPhase > searchFrontierPhase || !neighbor.Explorable ) { continue; } 

unitypackage

भाग २३: भूमि उत्पन्न करना

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

ट्यूटोरियल का यह हिस्सा प्रक्रियात्मक मानचित्र पीढ़ी पर एक श्रृंखला की शुरुआत होगी।

यह हिस्सा एकता 2017.1.0 में बनाया गया था।


कई उत्पन्न नक्शे में से एक।

कार्ड पीढ़ी

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

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

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

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

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

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

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

संपादन मोड में आरंभ करना

हम गेमप्ले पर नहीं बल्कि मानचित्र पर ध्यान केंद्रित करेंगे, इसलिए एप्लिकेशन को एडिट मोड में लॉन्च करना अधिक सुविधाजनक होगा। इसके लिए धन्यवाद, हम तुरंत कार्ड देख सकते हैं। इसलिए, हम HexMapEditor.Awakeसंपादन मोड को सही पर सेट करके और इस मोड के shader कीवर्ड को बदलकर बदल देंगे ।

  void Awake () { terrainMaterial.DisableKeyword("GRID_ON"); Shader.EnableKeyword("HEX_MAP_EDIT_MODE"); SetEditMode(true); } 

कार्ड जनरेटर

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

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

 using System.Collections.Generic; using UnityEngine; public class HexMapGenerator : MonoBehaviour { public HexGrid grid; public void GenerateMap (int x, int z) { grid.CreateMap(x, z); } } 

एक घटक को दृश्य के साथ जोड़ें HexMapGeneratorऔर इसे ग्रिड से कनेक्ट करें।


मानचित्र जनरेटर वस्तु।

एक नए नक्शे का मेनू बदलें

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

  bool generateMaps = true; public void ToggleMapGeneration (bool toggle) { generateMaps = toggle; } 

एक स्विच के साथ एक नया कार्ड का मेनू।

मेनू को मैप जनरेटर से लिंक करें। फिर हम इसे आवश्यक होने पर GenerateMapजनरेटर विधि को कॉल करने के लिए मजबूर करेंगे , और न केवल CreateMapग्रिड को निष्पादित करें ।

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

जनरेटर से कनेक्शन।

सेल का उपयोग

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

  public HexCell GetCell (int xOffset, int zOffset) { return cells[xOffset + zOffset * cellCountX]; } public HexCell GetCell (int cellIndex) { return cells[cellIndex]; } 

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

  public void GenerateMap (int x, int z) { grid.CreateMap(x, z); for (int i = 0; i < z; i++) { grid.GetCell(x / 2, i).TerrainTypeIndex = 1; } } 

एक छोटे से नक्शे पर घास का स्तंभ।

unitypackage

सुशी बनाना

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

राहत बढ़ाओ

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

  public void GenerateMap (int x, int z) { grid.CreateMap(x, z); // for (int i = 0; i < z; i++) { // grid.GetCell(x / 2, i).TerrainTypeIndex = 1; // } RaiseTerrain(7); } void RaiseTerrain (int chunkSize) {} 

अब तक, हम "घास" प्रकार के राहत का उपयोग ऊंचे भूमि को निरूपित करने के लिए करते हैं, और मूल "रेत" राहत महासागर को संदर्भित करती है। हमें RaiseTerrainएक यादृच्छिक सेल लें और जब तक हमें सही मात्रा में जमीन न मिल जाए, तब तक इसकी राहत के प्रकार को बदल दें।

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

  void RaiseTerrain (int chunkSize) { for (int i = 0; i < chunkSize; i++) { GetRandomCell().TerrainTypeIndex = 1; } } HexCell GetRandomCell () { return grid.GetCell(Random.Range(0, grid.cellCountX * grid.cellCountZ)); } 

सात यादृच्छिक सुशी कोशिकाओं।

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

  int cellCount; public void GenerateMap (int x, int z) { cellCount = x * z; … } … HexCell GetRandomCell () { return grid.GetCell(Random.Range(0, cellCount)); } 

एक साइट का निर्माण

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

हम HexMapGeneratorअपनी संपत्ति और खोज सीमा के चरण के काउंटर को जोड़ते हैं, जैसा कि यह था HexGrid।

  HexCellPriorityQueue searchFrontier; int searchFrontierPhase; 

जाँच करें कि प्राथमिकता कतार में मौजूद है जब हमें इसकी आवश्यकता है।

  public void GenerateMap (int x, int z) { cellCount = x * z; grid.CreateMap(x, z); if (searchFrontier == null) { searchFrontier = new HexCellPriorityQueue(); } RaiseTerrain(7); } 

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

  RaiseTerrain(7); for (int i = 0; i < cellCount; i++) { grid.GetCell(i).SearchPhase = 0; } 

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

  void RaiseTerrain (int chunkSize) { // for (int i = 0; i < chunkSize; i++) { // GetRandomCell().TerrainTypeIndex = 1; // } searchFrontierPhase += 1; HexCell firstCell = GetRandomCell(); firstCell.SearchPhase = searchFrontierPhase; firstCell.Distance = 0; firstCell.SearchHeuristic = 0; searchFrontier.Enqueue(firstCell); } 

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

  searchFrontier.Enqueue(firstCell); int size = 0; while (size < chunkSize && searchFrontier.Count > 0) { HexCell current = searchFrontier.Dequeue(); current.TerrainTypeIndex = 1; size += 1; for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = current.GetNeighbor(d); if (neighbor && neighbor.SearchPhase < searchFrontierPhase) { neighbor.SearchPhase = searchFrontierPhase; neighbor.Distance = 0; neighbor.SearchHeuristic = 0; searchFrontier.Enqueue(neighbor); } } } searchFrontier.Clear(); 

कोशिकाओं की एक पंक्ति।

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

हम कोशिकाओं को जोड़ते हैं

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

  searchFrontier.Enqueue(firstCell); HexCoordinates center = firstCell.coordinates; int size = 0; while (size < chunkSize && searchFrontier.Count > 0) { HexCell current = searchFrontier.Dequeue(); current.TerrainTypeIndex = 1; size += 1; for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) { HexCell neighbor = current.GetNeighbor(d); if (neighbor && neighbor.SearchPhase < searchFrontierPhase) { neighbor.SearchPhase = searchFrontierPhase; neighbor.Distance = neighbor.coordinates.DistanceTo(center); neighbor.SearchHeuristic = 0; searchFrontier.Enqueue(neighbor); } } } 

कोशिकाओं का संचय।

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

  RaiseTerrain(30); 

30 कोशिकाओं में सुशी द्रव्यमान।

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

सुशी यादृच्छिकरण

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

  neighbor.Distance = neighbor.coordinates.DistanceTo(center); neighbor.SearchHeuristic = Random.value < 0.5f ? 1: 0; searchFrontier.Enqueue(neighbor); 

विकृत क्षेत्र।

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

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

  [Range(0f, 0.5f)] public float jitterProbability = 0.25f; 

उतार-चढ़ाव की संभावना।


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

  neighbor.SearchHeuristic = Random.value < jitterProbability ? 1: 0; 

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

कुछ जमीन उठाते हैं

हम भूमि के एक टुकड़े की पीढ़ी तक सीमित नहीं रहेंगे। उदाहरण के लिए, हम RaiseTerrainपांच खंडों को प्राप्त करने के लिए एक लूप के अंदर कॉल करते हैं।

  for (int i = 0; i < 5; i++) { RaiseTerrain(30); } 

जमीन के पांच प्लॉट।

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

भूमि की परिवर्तनशीलता बढ़ाने के लिए, हम प्रत्येक भूखंड का आकार भी बदल सकते हैं। भूखंडों के न्यूनतम और अधिकतम आकार को नियंत्रित करने के लिए दो पूर्णांक फ़ील्ड जोड़ें। उदाहरण के लिए, उन्हें 20-200 तक पर्याप्त रूप से बड़ा अंतराल प्रदान करें। मैं मानक को न्यूनतम 30 के बराबर और मानक अधिकतम - 100 कर दूंगा।

  [Range(20, 200)] public int chunkSizeMin = 30; [Range(20, 200)] public int chunkSizeMax = 100; 

आकार देने का अंतराल।

इन क्षेत्रों का उपयोग हम बेतरतीब ढंग से उस क्षेत्र के आकार को निर्धारित करने के लिए करते हैं जब कहा जाता है RaiseTerrain।

  RaiseTerrain(Random.Range(chunkSizeMin, chunkSizeMax + 1)); 

बीच के नक्शे पर पांच बेतरतीब आकार के खंड।

पर्याप्त सुशी बनाएं

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

  [Range(5, 95)] public int landPercentage = 50; 

सुशी का प्रतिशत।

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

  public void GenerateMap (int x, int z) { … // for (int i = 0; i < 5; i++) { // RaiseTerrain(Random.Range(chunkSizeMin, chunkSizeMax + 1)); // } CreateLand(); for (int i = 0; i < cellCount; i++) { grid.GetCell(i).SearchPhase = 0; } } void CreateLand () { int landBudget = Mathf.RoundToInt(cellCount * landPercentage * 0.01f); } 

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

 // void RaiseTerrain (int chunkSize) { int RaiseTerrain (int chunkSize, int budget) { … return budget; } 

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

  while (size < chunkSize && searchFrontier.Count > 0) { HexCell current = searchFrontier.Dequeue(); if (current.TerrainTypeIndex == 0) { current.TerrainTypeIndex = 1; if (--budget == 0) { break; } } size += 1; … } 

अब यह CreateLandतब तक जमीन जुटा सकता है जब तक यह कोशिकाओं की पूरी मात्रा खर्च नहीं करता।

  void CreateLand () { int landBudget = Mathf.RoundToInt(cellCount * landPercentage * 0.01f); while (landBudget > 0) { landBudget = RaiseTerrain( Random.Range(chunkSizeMin, chunkSizeMax + 1), landBudget ); } } 

बिल्कुल आधा नक्शा जमीन बन गया।

unitypackage

ऊंचाई को ध्यान में रखें

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

जमीन को धकेल दो

प्रत्येक भूखंड समुद्र के नीचे से धकेल दिए गए भूमि के एक हिस्से का प्रतिनिधित्व करता है। इसलिए, चलो वर्तमान सेल की ऊँचाई को लगातार बढ़ाएँ RaiseTerrainऔर देखें कि क्या होता है।

  HexCell current = searchFrontier.Dequeue(); current.Elevation += 1; if (current.TerrainTypeIndex == 0) { … } 

ऊँचाई वाली भूमि।

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


ऊंचाई में प्रत्येक परिवर्तन के साथ सेल के इलाके प्रकार को अपडेट करने के बजाय, चलो SetTerrainTypeकेवल एक बार सभी इलाके प्रकार सेट करने के लिए एक अलग विधि बनाएं ।

  void SetTerrainType () { for (int i = 0; i < cellCount; i++) { HexCell cell = grid.GetCell(i); cell.TerrainTypeIndex = cell.Elevation; } } 

सुशी बनाने के बाद हम इस विधि को कहेंगे।

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

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

  HexCell current = searchFrontier.Dequeue(); current.Elevation += 1; if (current.Elevation == 1 && --budget == 0) { break; } // if (current.TerrainTypeIndex == 0) { // current.TerrainTypeIndex = 1; // if (--budget == 0) { // break; // } // } 

परतों का स्तरीकरण।

पानी डालें

आइए स्पष्ट रूप से इंगित करें कि कौन सी कोशिकाएँ पानी या भूमि हैं, सभी कोशिकाओं के लिए जल स्तर को 1 पर सेट करना GenerateMap। भूमि बनाने से पहले ऐसा करें ।

  public void GenerateMap (int x, int z) { cellCount = x * z; grid.CreateMap(x, z); if (searchFrontier == null) { searchFrontier = new HexCellPriorityQueue(); } for (int i = 0; i < cellCount; i++) { grid.GetCell(i).WaterLevel = 1; } CreateLand(); … } 

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

  void SetTerrainType () { for (int i = 0; i < cellCount; i++) { HexCell cell = grid.GetCell(i); if (!cell.IsUnderwater) { cell.TerrainTypeIndex = cell.Elevation - cell.WaterLevel; } } } 

जमीन और पानी।

जल स्तर बढ़ाएं

हम एक जल स्तर तक सीमित नहीं हैं। आइए इसे 1-5 के अंतराल और 3 के डिफ़ॉल्ट मान के साथ एक सामान्य फ़ील्ड का उपयोग करके अनुकूलन योग्य बनाएं। कोशिकाओं को शुरू करते समय इस स्तर का उपयोग करें।

  [Range(1, 5)] public int waterLevel = 3; … public void GenerateMap (int x, int z) { … for (int i = 0; i < cellCount; i++) { grid.GetCell(i).WaterLevel = waterLevel; } … } 

जल स्तर 3.

जब जल स्तर 3 होता है, तो हमें उम्मीद से कम जमीन मिलती है। ऐसा इसलिए है क्योंकि यह RaiseTerrainअभी भी मानता है कि पानी का स्तर 1 है। चलो इसे ठीक करें।

  HexCell current = searchFrontier.Dequeue(); current.Elevation += 1; if (current.Elevation == waterLevel && --budget == 0) { break; } 

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





जल स्तर 2-5 है, सुशी हमेशा 50% है।

unitypackage

ऊर्ध्वाधर आंदोलन

अब तक हमने एक समय में भूखंडों को एक स्तर ऊपर उठाया है, लेकिन हमें खुद को इस तक सीमित नहीं रखना है।

उच्च साइटें

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

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

कोशिकाओं में एक मजबूत वृद्धि की संभावना।

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

  int rise = Random.value < highRiseProbability ? 2 : 1; int size = 0; while (size < chunkSize && searchFrontier.Count > 0) { HexCell current = searchFrontier.Dequeue(); int originalElevation = current.Elevation; current.Elevation = originalElevation + rise; if ( originalElevation < waterLevel && current.Elevation >= waterLevel && --budget == 0 ) { break; } size += 1; … } 

ऊंचाई में मजबूत वृद्धि की संभावनाएं 0.25, 0.50, 0.75 और 1 हैं।

भूमि को कम करो

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


धँसा सुशी के बिना बड़ा नक्शा।

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

  [Range(0f, 0.4f)] public float sinkProbability = 0.2f; 

कम होने की संभावना।

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

  int SinkTerrain (int chunkSize, int budget) { … int sink = Random.value < highRiseProbability ? 2 : 1; int size = 0; while (size < chunkSize && searchFrontier.Count > 0) { HexCell current = searchFrontier.Dequeue(); int originalElevation = current.Elevation; current.Elevation = originalElevation - sink; if ( originalElevation >= waterLevel && current.Elevation < waterLevel // && --budget == 0 ) { // break; budget += 1; } size += 1; … } searchFrontier.Clear(); return budget; } 

अब, प्रत्येक पुनरावृत्ति पर, CreateLandहमें या तो कम करना चाहिए या भूमि को ऊपर उठाना चाहिए, जो कि कम होने की संभावना पर निर्भर करता है।

  void CreateLand () { int landBudget = Mathf.RoundToInt(cellCount * landPercentage * 0.01f); while (landBudget > 0) { int chunkSize = Random.Range(chunkSizeMin, chunkSizeMax - 1); if (Random.value < sinkProbability) { landBudget = SinkTerrain(chunkSize, landBudget); } else { landBudget = RaiseTerrain(chunkSize, landBudget); } } } 

छोड़ने की संभावना 0.1, 0.2, 0.3 और 0.4 है।

ऊँचाई की सीमा

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


90% भूमि पर भारी ऊंचाई।

ऊंचाई को सीमित करने के लिए, एक कस्टम न्यूनतम और अधिकतम जोड़ें। एक उचित न्यूनतम कहीं −4 और 0 के बीच होगा, और स्वीकार्य अधिकतम 6-10 की सीमा में हो सकता है। डिफ़ॉल्ट मानों को and2 और 8 होने दें। मानचित्र को मैन्युअल रूप से संपादित करते समय, वे अनुमेय सीमा के बाहर होंगे, इसलिए आप UI संपादक के स्लाइडर को बदल सकते हैं, या इसे छोड़ सकते हैं।

  [Range(-4, 0)] public int elevationMinimum = -2; [Range(6, 10)] public int elevationMaximum = 8; 

न्यूनतम और अधिकतम ऊंचाई।

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

  HexCell current = searchFrontier.Dequeue(); int originalElevation = current.Elevation; int newElevation = originalElevation + rise; if (newElevation > elevationMaximum) { continue; } current.Elevation = newElevation; if ( originalElevation < waterLevel && newElevation >= waterLevel && --budget == 0 ) { break; } size += 1; 

उसी में करें SinkTerrain, लेकिन न्यूनतम ऊंचाई के लिए।

  HexCell current = searchFrontier.Dequeue(); int originalElevation = current.Elevation; int newElevation = current.Elevation - sink; if (newElevation < elevationMinimum) { continue; } current.Elevation = newElevation; if ( originalElevation >= waterLevel && newElevation < waterLevel ) { budget += 1; } size += 1; 

90% भूमि के साथ सीमित ऊँचाई।

नकारात्मक ऊंचाई संरक्षण

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

हम इसे एक पूर्णांक के रूप में संग्रहीत करके ऋणात्मक ऊँचाइयों के लिए समर्थन जोड़ सकते हैं, बाइट नहीं। हालांकि, हमें अभी भी ऊंचाई के कई स्तरों का समर्थन करने की आवश्यकता नहीं है। इसके अलावा, हम 127 को जोड़कर संग्रहीत मूल्य को ऑफसेट कर सकते हैं। यह हमें एक बाइट के भीतर रेंज −127–128 में सही ढंग से ऊंचाइयों को स्टोर करने की अनुमति देगा। HexCell.Saveउसी के अनुसार बदलिए ।

  public void Save (BinaryWriter writer) { writer.Write((byte)terrainTypeIndex); writer.Write((byte)(elevation + 127)); … } 

चूंकि हमने मानचित्र डेटा को सहेजने के तरीके को बदल दिया है, इसलिए हम इसे SaveLoadMenu.mapFileVersion4 तक बढ़ाते हैं ।

  const int mapFileVersion = 4; 

और अंत में, इसे बदल दें HexCell.Loadताकि यह संस्करण 4 फाइलों से भरी हुई ऊंचाइयों से 127 को घटाए।

  public void Load (BinaryReader reader, int header) { terrainTypeIndex = reader.ReadByte(); ShaderData.RefreshTerrain(this); elevation = reader.ReadByte(); if (header >= 4) { elevation -= 127; } … } 

unitypackage

उसी नक्शे को फिर से बनाना

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

बीज का उपयोग करना

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

  public void GenerateMap (int x, int z) { Random.State originalRandomState = Random.state; … Random.state = originalRandomState; } 

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

  public int seed; 

बीज प्रदर्शित करें।

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

  public void GenerateMap (int x, int z) { Random.State originalRandomState = Random.state; seed = Random.Range(0, int.MaxValue); Random.InitState(seed); … } 

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

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

  seed = Random.Range(0, int.MaxValue); seed ^= (int)System.DateTime.Now.Ticks; seed ^= (int)Time.unscaledTime; Random.InitState(seed); 

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

  seed ^= (int)Time.unscaledTime; seed &= int.MaxValue; Random.InitState(seed); 

पुन: प्रयोज्य बीज

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

  public bool useFixedSeed; 

एक निरंतर बीज का उपयोग करने का विकल्प।

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

  Random.State originalRandomState = Random.state; if (!useFixedSeed) { seed = Random.Range(0, int.MaxValue); seed ^= (int)System.DateTime.Now.Ticks; seed ^= (int)Time.time; seed &= int.MaxValue; } Random.InitState(seed); 

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



बीज मान 0 और 929396788 के साथ बड़े कार्ड, मानक पैरामीटर।

unitypackage