👩‍❤️‍👩 🌩️ 😅 हम एकता पर Boid'ov का अनुकूलन करते हैं 🌱 🏯 🎨

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

यह लेख का दूसरा भाग है, जो अनुकूलन एकता और C # के विभिन्न ट्रिक्स को समर्पित है, जो पहले भाग से एल्गोरिथ्म के प्रदर्शन को दर्जनों बार बढ़ाता है।

संशोधनों की एक जोड़ी

मैं आपको याद दिला दूं कि हम कहां गए थे। अनुकूलन के बिना पिछले भाग से Boid.cs

using UnityEngine; public class Boid : MonoBehaviour { public Vector3 velocity; private float cohesionRadius = 10; private float separationDistance = 5; private Collider[] boids; private Vector3 cohesion; private Vector3 separation; private int separationCount; private Vector3 alignment; private float maxSpeed = 15; private void Start() { InvokeRepeating("CalculateVelocity", 0, 0.1f); } void CalculateVelocity() { velocity = Vector3.zero; cohesion = Vector3.zero; separation = Vector3.zero; separationCount = 0; alignment = Vector3.zero; boids = Physics.OverlapSphere(transform.position, cohesionRadius); foreach (var boid in boids) { cohesion += boid.transform.position; alignment += boid.GetComponent<Boid>().velocity; if (boid != collider && (transform.position - boid.transform.position).magnitude < separationDistance) { separation += (transform.position - boid.transform.position) / (transform.position - boid.transform.position).magnitude; separationCount++; } } cohesion = cohesion / boids.Length; cohesion = cohesion - transform.position; cohesion = Vector3.ClampMagnitude(cohesion, maxSpeed); if (separationCount > 0) { separation = separation / separationCount; separation = Vector3.ClampMagnitude(separation, maxSpeed); } alignment = alignment / boids.Length; alignment = Vector3.ClampMagnitude(alignment, maxSpeed); velocity += cohesion + separation * 10 + alignment * 1.5f; velocity = Vector3.ClampMagnitude(velocity, maxSpeed); } void Update() { if (transform.position.magnitude > 25) { velocity += -transform.position.normalized; } transform.position += velocity * Time.deltaTime; Debug.DrawRay(transform.position, separation, Color.green); Debug.DrawRay(transform.position, cohesion, Color.magenta); Debug.DrawRay(transform.position, alignment, Color.blue); } }

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

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

 if (velocity != Vector3.zero && transform.forward != velocity.normalized) { transform.forward = Vector3.RotateTowards(transform.forward, velocity, 10, 1); }

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

 var boid = Instantiate(boidPrefab, Random.insideUnitSphere * 25, Quaternion.identity) as Transform; boid.parent = transform;

व्यापार के लिए नीचे उतर रहा है

चलिए शुरुआत करते हैं केले के साथ। हमारे लूप में, ट्रांसफ़ॉर्मिंग ट्रांसफ़ॉर्मिंग। पोज़िशन - boid.transform.position तीन बार किया जाता है। यह खराब है, परिणाम को एक चर में रखना बेहतर है। सौ वरदानों पर, यह बात नहीं हो सकती है, लेकिन एक चक्र में हजार के एक जोड़े पर और यहां तक कि प्रति सेकंड कई बार, अंतर पहले से ही होगा।

 var vector = transform.position - boid.transform.position; if (boid != collider && vector.magnitude < separationDistance) { separation += vector / vector.magnitude; separationCount++; }

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

 if (boid != collider && vector.sqrMagnitude < separationDistance * separationDistance) { separation += vector / vector.sqrMagnitude; separationCount++; } … if (transform.position.sqrMagnitude > 25 * 25) { velocity += -transform.position.normalized; }

रूपांतरण और GetComponent

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

 public Transform tr; void Awake() { tr = transform; }

Tr के साथ बदलने के लिए सभी कॉल बदलें।

 foreach (var boid in boids) { var b = boid.GetComponent<Boid>(); cohesion += b.tr.position; alignment += b.velocity; if (vector.sqrMagnitude > 0 && (tr.position - b.tr.position).magnitude < separationDistance) { separation += (tr.position - b.tr.position) / (tr.position - b.tr.position).magnitude; separationCount++; } }

हम आगे भी अनुकूलन करेंगे

ठीक है, यह पहले से बहुत बेहतर है, लेकिन लड़कों के बहुत करीब आने पर भी एफपीएस अभी भी कमज़ोर है। और सभी क्योंकि Physics.OverlapSphere कोलाइडर की बढ़ती संख्या पर कब्जा करने के लिए शुरू होता है और हम सभी boes पर सरल गणना के लगभग समान द्विघात जटिलता प्राप्त करते हैं।

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

 private int maxBoids = 5; … boids = Physics.OverlapSphere(tr.position, cohesionRadius); if (boids.Length < 2) return; … for (var i = 0; i < boids.Length && i < maxBoids; i++) { var b = boids[i].GetComponent<Boid>(); cohesion += b.tr.position; alignment += b.velocity; var vector = tr.position - b.tr.position; if (vector.sqrMagnitude > 0 && vector.sqrMagnitude < separationDistance * separationDistance) { separation += vector / vector.magnitude; separationCount++; } } cohesion = cohesion / (boids.Length > maxBoids ? maxBoids : boids.Length);

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

 public int turnSpeed = 10; public int maxSpeed = 15; public float cohesionRadius = 7; public int maxBoids = 10; public float separationDistance = 5; public float cohesionCoefficient = 1; public float alignmentCoefficient = 4; public float separationCoefficient = 10; public float tick = 2; [HideInInspector] public Vector3 velocity; [HideInInspector] public Transform tr; … InvokeRepeating("CalculateVelocity", 0, tick);

अगला, अपने कानों के साथ एक फिंट करें और ताज़ा दर को 2 सेकंड के लिए सेट करें। हाँ, हाँ, आपने सही सुना, हमारे मुकाबले बीस गुना कम। उसी समय, हम कारकों को सही करेंगे। अब, सैकड़ों boids के बजाय, हम एक हजार बना सकते हैं।

अनुकूलित, अनुकूलित, लेकिन अनुकूलित नहीं

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

 InvokeRepeating("CalculateVelocity", Random.value * tick, tick);

ठीक है, ताकि अनुकरण की शुरुआत बहुत अजीब न लगे, जागने में हम random.onUnitSphere से यादृच्छिकता का एक तत्व भी जोड़ते हैं।

 velocity = Random.onUnitSphere * maxSpeed;

हम अपने कोड को अधिक बारीकी से देखते हैं।

 var b = boids[i].GetComponent<Boid>(); … var vector = tr.position - b.tr.position;

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

 private Boid b; private Vector3 vector; private int i;

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

 velocity += -tr.position.normalized;

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

 velocity += -tr.position/25;

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

 InvokeRepeating("UpdateRotation", Random.value, 0.1f); … void UpdateRotation() { if (velocity != Vector3.zero && model.forward != velocity.normalized) { model.forward = Vector3.RotateTowards(model.forward, velocity, turnSpeed, 1); } }

भौतिक विज्ञान

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

 public LayerMask boidsLayer; … boids = Physics.OverlapSphere(tr.position, cohesionRadius, boidsLayer.value);

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

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

 public Transform model; … if (velocity != Vector3.zero && model.forward != velocity.normalized) { model.forward = Vector3.RotateTowards(model.forward, velocity, turnSpeed, 1); }

निष्कर्ष

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

Boid.cs का अनुकूलित संस्करण

 using UnityEngine; public class Boid : MonoBehaviour { public int turnSpeed = 10; public int maxSpeed = 15; public float cohesionRadius = 7; public int maxBoids = 10; public float separationDistance = 5; public float cohesionCoefficient = 1; public float alignmentCoefficient = 4; public float separationCoefficient = 10; public float tick = 2; public Transform model; public LayerMask boidsLayer; [HideInInspector] public Vector3 velocity; [HideInInspector] public Transform tr; private Collider[] boids; private Vector3 cohesion; private Vector3 separation; private int separationCount; private Vector3 alignment; private Boid b; private Vector3 vector; private int i; void Awake() { tr = transform; velocity = Random.onUnitSphere*maxSpeed; } private void Start() { InvokeRepeating("CalculateVelocity", Random.value * tick, tick); InvokeRepeating("UpdateRotation", Random.value, 0.1f); } void CalculateVelocity() { boids = Physics.OverlapSphere(tr.position, cohesionRadius, boidsLayer.value); if (boids.Length < 2) return; velocity = Vector3.zero; cohesion = Vector3.zero; separation = Vector3.zero; separationCount = 0; alignment = Vector3.zero; for (i = 0; i < boids.Length && i < maxBoids; i++) { b = boids[i].GetComponent<Boid>(); cohesion += b.tr.position; alignment += b.velocity; vector = tr.position - b.tr.position; if (vector.sqrMagnitude > 0 && vector.sqrMagnitude < separationDistance * separationDistance) { separation += vector / vector.sqrMagnitude; separationCount++; } } cohesion = cohesion / (boids.Length > maxBoids ? maxBoids : boids.Length); cohesion = Vector3.ClampMagnitude(cohesion - tr.position, maxSpeed); cohesion *= cohesionCoefficient; if (separationCount > 0) { separation = separation / separationCount; separation = Vector3.ClampMagnitude(separation, maxSpeed); separation *= separationCoefficient; } alignment = alignment / (boids.Length > maxBoids ? maxBoids : boids.Length); alignment = Vector3.ClampMagnitude(alignment, maxSpeed); alignment *= alignmentCoefficient; velocity = Vector3.ClampMagnitude(cohesion + separation + alignment, maxSpeed); } void UpdateRotation() { if (velocity != Vector3.zero && model.forward != velocity.normalized) { model.forward = Vector3.RotateTowards(model.forward, velocity, turnSpeed, 1); } } void Update() { if (tr.position.sqrMagnitude > 25 * 25) { velocity += -tr.position / 25; } tr.position += velocity * Time.deltaTime; } }

गिटहब पर सूत्र | एकता वेब प्लेयर के मालिकों के लिए ऑनलाइन संस्करण

हम एकता पर Boid'ov का अनुकूलन करते हैं