🌑 🆔 ⛑️ एकता में घटना प्रणाली का संगठन - एक गेम डिजाइनर की आंखों के माध्यम से 😻 ⚰️ 😺

सभी को नमस्कार!

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

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

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

मुझे इस विषय पर किसी भी आलोचना की खुशी होगी कि यह आवश्यक क्यों नहीं है, और यह सब कैसे करना है।

शुरू करने के लिए, मैंने दो गेमऑबजेक्ट को मापदंडों के रूप में पारित करने के लिए एकता घटनाओं की मानक कार्यक्षमता को फिर से परिभाषित किया: विषय और घटना वस्तु:

[System.Serializable] public class Event : UnityEvent<GameObject, GameObject> {}

मैं स्थैतिक वर्ग में सभी प्रकार के स्थिरांक के साथ ईवेंट प्रकारों को संग्रहीत करता हूं:

 public enum EventTypes { TargetLock, TargetLost, TargetInRange, TargetOutOfRange, Attack, }

इन घटनाओं का हैंडलर वर्ग तुच्छ है।

 public class EventManager : MonoBehaviour { Dictionary<EventTypes, Event> events; static EventManager eventManager; public static EventManager Instance { get { if (!eventManager) { eventManager = FindObjectOfType(typeof(EventManager)) as EventManager; if (!eventManager) { print("no event manager"); } else { eventManager.Init(); } } return eventManager; } } void Init() { if (events == null) { events = new Dictionary<EventTypes, Event>(); } } public static void StartListening(EventTypes eventType, UnityAction<GameObject, GameObject> listener) { if (Instance.events.TryGetValue(eventType, out Event thisEvent)) { thisEvent.AddListener(listener); } else { thisEvent = new Event(); thisEvent.AddListener(listener); Instance.events.Add(eventType, thisEvent); } } public static void StopListening(EventTypes eventType, UnityAction<GameObject, GameObject> listener) { if (eventManager == null) return; if (Instance.events.TryGetValue(eventType, out Event thisEvent)) { thisEvent.RemoveListener(listener); } } public static void TriggerEvent(EventTypes eventType, GameObject obj1, GameObject obj2) { if (Instance.events.TryGetValue(eventType, out Event thisEvent)) { thisEvent.Invoke(obj1, obj2); } } }

फिर मैंने इवेंट्स घटक बनाया, जो खेल में प्रत्येक ऑब्जेक्ट से जुड़ा हुआ है।
इसमें, मैं खेल में सभी प्रकार के कार्यक्रमों के लिए इवेंट-हैंडलर जोड़े बनाता हूं।

 public class Events : MonoBehaviour { Dictionary<EventTypes, UnityAction<GameObject, GameObject>> eventHandlers; void HandlersInit() { eventHandlers = new Dictionary<EventTypes, UnityAction<GameObject, GameObject>> { { EventTypes.TargetLock, TargetLock }, { EventTypes.TargetLost, TargetLost }, { EventTypes.TargetInRange, TargetInRange }, { EventTypes.TargetOutOfRange, TargetOutOfRange }, { EventTypes.Attack, Attack }, }; } }

नतीजतन, फ़ाइल बोझिल है, लेकिन यह मेरे लिए सुविधाजनक है कि यह एक है - एक बार में सभी वस्तुओं के लिए।

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

  void OnEnable() { foreach (KeyValuePair<EventTypes, UnityAction<GameObject, GameObject>> pair in eventHandlers) StartListening(pair.Key, pair.Value); } void OnDisable() { foreach (KeyValuePair<EventTypes, UnityAction<GameObject, GameObject>> pair in eventHandlers) StopListening(pair.Key, pair.Value); }

अब मुझे यह समझने की जरूरत है कि इस घटना का उदाहरण किस वस्तु से जुड़ा है।

ऐसा करने के लिए, मैं gameObject से घटकों के लिंक की तलाश करता हूं: उदाहरण के लिए, यदि हमारी वस्तु चरित्र है, तो संबंधित क्षेत्र बन जाएगा! = Null:

  Monster _mob; Character _char; void ComponentsInit() { _mob = GetComponent<Monster>(); _char = GetComponent<Character>(); }

यह एक महंगा ऑपरेशन है, लेकिन मैं इसे केवल एक बार अवेक () में करता हूं।

अब यह सभी प्रकार की घटनाओं के लिए हैंडलर का वर्णन करने के लिए बनी हुई है:

  void TargetLock(GameObject g1, GameObject g2) { if (_char) _char.TargetLock(g1, g2); if (_mob) _mob.TargetLock(g1, g2); }

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

तदनुसार, चरित्र या राक्षस घटकों के अंदर, मैं पहले से ही ऐसा कुछ लिख रहा हूं:

  public virtual void TargetLock(GameObject g1, GameObject g2) { if (g1 == gameObject) target = g2; if (g2 == gameObject) TargetedBy(g1); }

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

अब तक, मुझे किसी भी ध्यान देने योग्य प्रदर्शन समस्याओं का सामना नहीं करना पड़ा है: सिस्टम "अपूर्ण" 100 + प्रकार की घटनाओं और स्क्रीन पर दर्जनों वस्तुओं के साथ काम करता है, यहां तक कि समय-संवेदी घटनाओं को संसाधित करता है जैसे कि एक तीर से एक चरित्र के साथ टकराव से नुकसान उठाना।

एकता में घटना प्रणाली का संगठन - एक गेम डिजाइनर की आंखों के माध्यम से

More articles: