👔 🌘 🐓 नौकरी प्रणाली और खोज पथ 🧑🏿 👧🏾 ⛰️

नक्शा

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

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

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

सिस्टम ऑपरेशन उदाहरण

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

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

यह मूल रूप से एक शुरुआत के लिए है, लेकिन हम नहीं रुके और तुरंत व्यापार में उतर गए।

स्क्रिप्ट के साथ शुरू करते हैं। और पहला है बाधा बाधा लिपि।

बाधा

public class Obstacle : MonoBehaviour { }

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

नक्शा

 public sealed class Map : Obstacle { }

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

ऐसा करने के लिए, ऑब्जेक्ट परिवर्तन को ट्रैक करने के लिए सभी आवश्यक चर और विधियों के साथ बाधा बेस क्लास भरें।

बाधा

 public class Obstacle : MonoBehaviour { public new SpriteRenderer renderer { get; private set;} private Vector2 tempSize; private Vector2 tempPos; protected virtual void Awake() { this.renderer = GetComponent<SpriteRenderer>(); this.tempSize = this.size; this.tempPos = this.position; } public virtual bool CheckChanges() { Vector2 newSize = this.size; float diff = (newSize - this.tempSize).sqrMagnitude; if (diff > 0.01f) { this.tempSize = newSize; return true; } Vector2 newPos = this.position; diff = (newPos - this.tempPos).sqrMagnitude; if (diff > 0.01f) { this.tempPos = newPos; return true; } return false; } public Vector2 size { get { return this.renderer.bounds.size;} } public Vector2 position { get { return this.transform.position;} } }

यहां, रेंडरर वैरिएबल में SpriteRenderer कंपोनेंट का संदर्भ होगा, और टेम्पेसाइज और टेम्पपोस वेरिएबल्स का उपयोग ऑब्जेक्ट के आकार और स्थिति में परिवर्तन को ट्रैक करने के लिए किया जाएगा।

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

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

नक्शा

 public sealed class Map : Obstacle { [Range(0.1f, 1f)] public float nodeSize = 0.5f; public Vector2 offset = new Vector2(0.5f, 0.5f); }

नोडाइज़ करें चर मानचित्र पर कोशिकाओं के आकार को इंगित करेगा, यहां मैंने इसका आकार 0.1 से 1 तक सीमित किया है ताकि ग्रिड पर कोशिकाएं बहुत छोटी न हों, बल्कि बहुत बड़ी भी हों। ऑफसेट चर का उपयोग ग्रिड का निर्माण करते समय मानचित्र को इंडेंट करने के लिए किया जाएगा ताकि ग्रिड मानचित्र के किनारों के साथ न बने।

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

नक्शा

 public sealed class Map : Obstacle { [Range(0.1f, 1f)] public float nodeSize = 0.5f; public Vector2 offset = new Vector2(0.5f, 0.5f); private float tempNodeSize; private Vector2 tempOffset; protected override void Awake() { base.Awake(); this.tempNodeSize = this.nodeSize; this.tempOffset = this.offset; } public override bool CheckChanges() { float diff = Mathf.Abs(this.tempNodeSize - this.nodeSize); if (diff > 0.01f) { this.tempNodeSize = this.nodeSize; return true; } diff = (this.tempOffset - this.offset).sqrMagnitude; if (diff > 0.01f) { this.tempOffset = this.offset; return true; } return base.CheckChanges(); } }

हो गया। अब आप मंच पर एक मानचित्र स्प्राइट बना सकते हैं और उस पर एक मैप स्क्रिप्ट फेंक सकते हैं।

हम एक बाधा के साथ ऐसा ही करेंगे - मंच पर एक सरल स्प्राइट बनाएं और उस पर बाधा स्क्रिप्ट को फेंक दें।

अब हमारे पास मंच पर मानचित्र ऑब्जेक्ट्स और बाधाएं हैं।

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

नक्शा

 public sealed class Map : Obstacle { /*... …*/ private bool requireRebuild; private void Update() { UpdateChanges(); } private void UpdateChanges() { if (this.requireRebuild) { print(“  ,   !”); this.requireRebuild = false; } else { this.requireRebuild = CheckChanges(); } } /*... …*/ }

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

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

मानचित्र कक्षा में, मानचित्र पर सभी संभावित बाधाओं की सूची और उन्हें पंजीकृत करने के लिए स्थैतिक तरीकों की एक जोड़ी बनाएं।

नक्शा

 public sealed class Map : Obstacle { /*... …*/ private static Map ObjInstance; private List<Obstacle> obstacles = new List<Obstacle>(); /*... …*/ public static bool RegisterObstacle(Obstacle obstacle) { if (obstacle == Instance) return false; else if (Instance.obstacles.Contains(obstacle) == false) { Instance.obstacles.Add(obstacle); Instance.requireRebuild = true; return true; } return false; } public static bool UnregisterObstacle(Obstacle obstacle) { if (Instance.obstacles.Remove(obstacle)) { Instance.requireRebuild = true; return true; } return false; } public static Map Instance { get { if (ObjInstance == null) ObjInstance = FindObjectOfType<Map>(); return ObjInstance; } } }

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

स्थिर UnregisterObstructionle विधि, इसके विपरीत, नक्शे से बाधा को समाप्त करती है और इसे सूची से हटा देती है जब हम इसे नष्ट करने की अनुमति देते हैं।

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

इसके अलावा, किसी भी स्क्रिप्ट से मैप स्क्रिप्ट तक आसानी से पहुंचने के लिए, मैंने एक स्टैटिक इंस्टैंस प्रॉपर्टी बनाई, जो मैप के इस बहुत ही उदाहरण पर मुझे लौटाएगी ।

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

बाधा

 public class Obstacle : MonoBehaviour { /*... …*/ protected virtual void OnEnable() { Map.RegisterObstacle(this); } protected virtual void OnDisable() { Map.UnregisterObstacle(this); } }

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

यह केवल ओवरलोडेड चेकचेंज विधि में मैप स्क्रिप्ट में बाधाओं के परिवर्तन को ट्रैक करने के लिए बनी हुई है।

नक्शा

 public sealed class Map : Obstacle { /*... …*/ public override bool CheckChanges() { float diff = Mathf.Abs(this.tempNodeSize - this.nodeSize); if (diff > 0.01f) { this.tempNodeSize = this.nodeSize; return true; } diff = (this.tempOffset - this.offset).sqrMagnitude; if (diff > 0.01f) { this.tempOffset = this.offset; return true; } foreach(Obstacle obstacle in this.obstacles) { if (obstacle.CheckChanges()) return true; } return base.CheckChanges(); } /*... …*/ }

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

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

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

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

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

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

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

सबसे पहले, एक बिंदु वस्तु को परिभाषित करते हैं, यह एक सरल नोड संरचना होगी।

नोड

 public struct Node { public int id; public Vector2 position; public Vector2Int coords; }

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

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

NodeType और Node

 public enum NodeType { NonWalkable = 0, Walkable = 1 } public struct Node { public int id; public Vector2 position; public Vector2Int coords; private int nodeType; public bool isWalkable { get { return this.nodeType == (int)NodeType.Walkable;} } public Node(int id, Vector2 position, Vector2Int coords, NodeType type) { this.id = id; this.position = position; this.coords = coords; this.nodeType = (int)type; } }

इसके अलावा, एक बिंदु के साथ काम करने की सुविधा के लिए, मैं अंक की तुलना करने के लिए आसान बनाने के लिए समान पद्धति को अधिभारित करूंगा और एक बिंदु के अस्तित्व के लिए सत्यापन विधि को पूरक करूंगा।

नोड

 public struct Node { /*... …*/ public override bool Equals(object obj) { if (obj is Node) { Node other = (Node)obj; return this.id == other.id; } else return base.Equals(obj); } public static implicit operator bool(Node node) { return node.id > 0; } }

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

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

नक्शा

 public sealed class Map : Obstacle { /*... …*/ public bool rebuilding { get; private set; } public void Rebuild() {} private void OnRebuildStart() {} private void OnRebuildFinish() {} /*... …*/ }

पुनर्निर्माण संपत्ति इंगित करेगी कि क्या मेशिंग प्रक्रिया जारी है। पुनर्निर्माण विधि ग्रिड के निर्माण के लिए डेटा और कार्यों को एकत्रित करेगी, फिर OnRebuildStart विधि ग्रिड निर्माण प्रक्रिया शुरू करेगी और OnRebuildFinish विधि कार्यों से डेटा एकत्र करेगी।

अब चलिए UpdateChanges मेथड को थोड़ा बदलते हैं ताकि ग्रिड कंडीशन को ध्यान में रखा जाए।

नक्शा

 public sealed class Map : Obstacle { /*... …*/ public bool rebuilding { get; private set; } private void UpdateChanges() { if (this.rebuilding) { print(“  ...”); } else { if (this.requireRebuild) { print(“  ,   !”); Rebuild(); } else { this.requireRebuild = CheckChanges(); } } } public void Rebuild() { if (this.rebuilding) return; print(“ !”); OnRebuildStart(); } private void OnRebuildStart() { this.rebuilding = true; } private void OnRebuildFinish() { this.rebuilding = false; } /*... …*/ }

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

समस्या हल करना

अब थोड़ा नक्शा बनाने की प्रक्रिया के बारे में।
चूंकि हम कार्य प्रणाली का उपयोग करेंगे और नक्शे के समानांतर में ग्रिड का निर्माण करेंगे, मैंने IJobParallelFor के प्रकार का उपयोग किया, जिसे निश्चित समय पर किया जाएगा। किसी एक अलग कार्य के साथ निर्माण प्रक्रिया को लोड नहीं करने के लिए, हम एक जॉबहैंडल में पैक किए गए कार्यों के पूल का उपयोग करेंगे।

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

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

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

और इसलिए हमारे पास बिंदु संरचना है, अब आप अय्यूब कार्य की संरचना बना सकते हैं और इसे IJobParallelFor इंटरफ़ेस से विरासत में प्राप्त कर सकते हैं, यहाँ सब कुछ सरल है।

काम

 public struct Job : IJobParallelFor { public void Execute(int index) {} }

हम मानचित्र वर्ग पुनर्निर्माण विधि पर लौटते हैं, जहां हम ग्रिड माप के लिए आवश्यक गणना करेंगे।

नक्शा

 public sealed class Map : Obstacle { /*... ...*/ public void Rebuild() { if (this.rebuilding) return; print(“ !”); Vector2 mapSize = this.size - this.offset * 2f; int horizontals = Mathf.RoundToInt(mapSize.x / this.nodeSize); int verticals = Mathf.RoundToInt(mapSize.y / this.nodeSize); if (horizontals <= 0) { OnRebuildFinish(); return; } Vector2 center = this.position; Vector2 origin = center - (mapSize / 2f); OnRebuildStart(); } /*... ...*/ }

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

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

काम

 public struct Job : IJobParallelFor { [WriteOnly] public NativeArray<Node> array; [ReadOnly] public NativeArray<Rect> bounds; public float nodeSize; public Vector2 startPos; public Vector2Int startCoords; public void Execute(int index) {} }

मैंने विशेषता WriteOnly के साथ अंकों की सरणी को चिह्नित किया है , क्योंकि कार्य में यह केवल सरणी को प्राप्त बिंदुओं को " लिखना " आवश्यक होगा, इसके विपरीत, बाधाओं की सरणी को ReadOnly विशेषता के साथ चिह्नित किया गया है क्योंकि इस कार्य से हम इस सरणी के डेटा को केवल " रीड " करेंगे।

ठीक है, अभी के लिए, चलो बाद में खुद अंकों की गणना के लिए आगे बढ़ें।

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

नक्शा

 public sealed class Map : Obstacle { /*... ...*/ private JobHandle handle; private NativeArray<Rect> bounds; private HashSet<NativeArray<Node>> jobs = new HashSet<NativeArray<Node>>(); private Dictionary<Vector2Int, Node> nodes = new Dictionary<Vector2Int, Node>(); /*... ...*/ }

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

फिर से बनाना

 public void Rebuild() { /*... ...*/ Vector2 center = this.position; Vector2 origin = center - (mapSize / 2f); int count = this.obstacles.Count; if (count > 0) { this.bounds = new NativeArray<Rect>(count, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); } OnRebuildStart(); }

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

और इसलिए, फिर हम डेटा के साथ सीमा सरणी भरते हैं।

फिर से बनाना

 public void Rebuild() { /*... ...*/ Vector2 center = this.position; Vector2 origin = center - (mapSize / 2f); int count = this.obstacles.Count; if (count > 0) { this.bounds = new NativeArray<Rect>(count, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); for(int i = 0; i < count; i++) { Obstacle obs = this.obstacles[i]; Vector2 position = obs.position; Rect rect = new Rect(Vector2.zero, obs.size); rect.center = position; this.bounds[i] = rect; } } OnRebuildStart(); }

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

फिर से बनाना

 public void Rebuild() { /*... ...*/ Vector2 center = this.position; Vector2 origin = center - (mapSize / 2f); int count = this.obstacles.Count; if (count > 0) { this.bounds = new NativeArray<Rect>(count, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); for(int i = 0; i < count; i++) { Obstacle obs = this.obstacles[i]; Vector2 position = obs.position; Rect rect = new Rect(Vector2.zero, obs.size); rect.center = position; this.bounds[i] = rect; } } for (int i = 0; i < verticals; i++) { float xPos = origin.x; float yPos = origin.y + (i * this.nodeSize) + this.nodeSize / 2f; } OnRebuildStart(); }

XPos और yPos के साथ शुरू करने के लिए, हमें श्रृंखला की प्रारंभिक क्षैतिज स्थिति मिलती है।

फिर से बनाना

 public void Rebuild() { /*... ...*/ Vector2 center = this.position; Vector2 origin = center - (mapSize / 2f); int count = this.obstacles.Count; if (count > 0) { this.bounds = new NativeArray<Rect>(count, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); for(int i = 0; i < count; i++) { Obstacle obs = this.obstacles[i]; Vector2 position = obs.position; Rect rect = new Rect(Vector2.zero, obs.size); rect.center = position; this.bounds[i] = rect; } } for (int i = 0; i < verticals; i++) { float xPos = origin.x; float yPos = origin.y + (i * this.nodeSize) + this.nodeSize / 2f; NativeArray<Node> array = new NativeArray<Node>(horizontals, Allocator.Persistent); Job job = new Job(); job.startCoords = new Vector2Int(i * horizontals, i); job.startPos = new Vector2(xPos, yPos); job.nodeSize = this.nodeSize; job.bounds = this.bounds; job.array = array; } OnRebuildStart(); }

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

फिर से बनाना

 public void Rebuild() { /*... ...*/ Vector2 center = this.position; Vector2 origin = center - (mapSize / 2f); int count = this.obstacles.Count; if (count > 0) { this.bounds = new NativeArray<Rect>(count, Allocator.TempJob, NativeArrayOptions.UninitializedMemory); for(int i = 0; i < count; i++) { Obstacle obs = this.obstacles[i]; Vector2 position = obs.position; Rect rect = new Rect(Vector2.zero, obs.size); rect.center = position; this.bounds[i] = rect; } } for (int i = 0; i < verticals; i++) { float xPos = origin.x; float yPos = origin.y + (i * this.nodeSize) + this.nodeSize / 2f; NativeArray<Node> array = new NativeArray<Node>(horizontals, Allocator.Persistent); Job job = new Job(); job.startCoords = new Vector2Int(i * horizontals, i); job.startPos = new Vector2(xPos, yPos); job.nodeSize = this.nodeSize; job.bounds = this.bounds; job.array = array; this.handle = job.Schedule(horizontals, 3, this.handle); this.jobs.Add(array); } OnRebuildStart(); }

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

OnRebuildStart

 private void OnRebuildStart() { this.rebuilding = true; this.handle.Complete(); }

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

UpdateChanges

 private void UpdateChanges() { if (this.rebuilding) { print(“  ...”); if (this.handle.IsCompleted) OnRebuildFinish(); } else { if (this.requireRebuild) { print(“  ,   !”); Rebuild(); } else { this.requireRebuild = CheckChanges(); } } }

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

OnRebuildFinish

  private void OnRebuildFinish() { this.nodes.Clear(); foreach (NativeArray<Node> array in this.jobs) { foreach (Node node in array) this.nodes.Add(node.coords, node); array.Dispose(); } this.jobs.Clear(); if (this.bounds.IsCreated) this.bounds.Dispose(); this.requireRebuild = this.rebuilding = false; }

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

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

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

कुछ इस तरह

ऐसा करने के लिए, मैप क्लास में, ऑनड्राग्रिजमोस विधि बनाएं जहां हम बिंदुओं को आकर्षित करेंगे।

नक्शा

 public sealed class Map : Obstacle { /*... …*/ #if UNITY_EDITOR private void OnDrawGizmos() {} #endif }

अब लूप के माध्यम से हम प्रत्येक बिंदु को आकर्षित करते हैं।

नक्शा

 public sealed class Map : Obstacle { /*... …*/ #if UNITY_EDITOR private void OnDrawGizmos() { foreach (Node node in this.nodes.Values) { Gizmos.DrawWireSphere(node.position, this.nodeSize / 10f); } } #endif }

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

जाल

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

नक्शा

 public sealed class Map : Obstacle { public static readonly Vector2Int[] Directions = { Vector2Int.up, new Vector2Int(1, 1), Vector2Int.right, new Vector2Int(1, -1), Vector2Int.down, new Vector2Int(-1, -1), Vector2Int.left, new Vector2Int(-1, 1), }; /*... …*/ public Node GetNode(Vector2Int coords) { Node result = default(Node); try { result = this.nodes[coords]; } catch {} return result; } #if UNITY_EDITOR private void OnDrawGizmos() {} #endif }

GetNode पद्धति नोड्स सूची से निर्देशांक द्वारा एक बिंदु लौटाएगी , लेकिन आपको इसे सावधानीपूर्वक करने की आवश्यकता है, क्योंकि अगर वेक्टर2Int निर्देशांक गलत हैं, तो एक त्रुटि उत्पन्न होगी, इसलिए यहां हम try catch अपवाद ब्लॉक का उपयोग करते हैं , जो अपवाद को पार करने में मदद करेगा और एक त्रुटि के साथ पूरे एप्लिकेशन को " हैंग " नहीं करेगा ।

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

OnDrawGizmos

  #if UNITY_EDITOR private void OnDrawGizmos() { Color c = Gizmos.color; foreach (Node node in this.nodes.Values) { Color newColor = Color.white; if (node.isWalkable) newColor = new Color32(153, 255, 51, 255); else newColor = Color.red; Gizmos.color = newColor; Gizmos.DrawWireSphere(node.position, this.nodeSize / 10f); newColor = Color.green; Gizmos.color = newColor; if (node.isWalkable) { for (int i = 0; i < Directions.Length; i++) { Vector2Int coords = node.coords + Directions[i]; Node connection = GetNode(coords); if (connection) { if (connection.isWalkable) Gizmos.DrawLine(node.position, connection.position); } } } } Gizmos.color = c; } #endif

अब आप सुरक्षित रूप से खेल शुरू कर सकते हैं और देख सकते हैं कि क्या हुआ।

गतिशील नक्शा

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

नक्शा और पथ खोज

तो आप अपने लक्ष्यों के लिए नई कार्य प्रणाली का उपयोग कर सकते हैं और बिना अधिक प्रयास के दिलचस्प प्रणाली का निर्माण कर सकते हैं।

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

पाथ फाइंडर प्रोजेक्ट सोर्स

नौकरी प्रणाली और खोज पथ

नक्शा

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

समस्या हल करना

More articles: