क्या एकल सूची में सभी गेम ऑब्जेक्ट को एक स्वीकार्य डिज़ाइन स्टोर करना है?


24

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

मैं सोच रहा था, क्या यह चीजों के बारे में जाने का सही तरीका है, या एक और अधिक कुशल तरीका है?


4
मुझे लगता है कि आपने कहा है "सरणी सूची", यह मानते हुए कि .Net, आपको इसके बजाय एक सूची <T> में अपग्रेड करना चाहिए। यह लगभग समान है, सिवाय इसके कि एक सूची <T> प्रकार-मजबूत है और इसके कारण, आपको हर बार जब आप किसी तत्व का उपयोग करते हैं तो आपको कास्ट टाइप नहीं करना पड़ेगा। यहाँ डॉक्टर है: msdn.microsoft.com/en-us/library/6sh2ey19.aspx
जॉन मैकडॉनल्ड्स

जवाबों:


26

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

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

आप अपनी संस्थाओं की जिम्मेदारियों को और भी बेहतर बना सकते हैं - यह लगता है कि दोनों संस्थाएँ इस समय अद्यतन और खुद को प्रस्तुत करती हैं - एकल जिम्मेदारी सिद्धांत का बेहतर पालन करने के लिए। यह आपके व्यक्तिगत इंटरफेस की स्थिरता और लचीलेपन को एक-दूसरे से विघटित करके बढ़ा सकता है। लेकिन फिर, चाहे या आपको अतिरिक्त कार्य से एक लाभ दिखाई देगा जो मुझे रोमांचित करेगा, मेरे लिए यह जानना कठिन है कि मैं आपके गेम के बारे में क्या जानता हूं (जो कि मूल रूप से कुछ भी नहीं है)।

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


16

जैसा कि दूसरों ने कहा है, अगर यह काफी तेज है, तो यह काफी तेज है। यदि आप सोच रहे हैं कि क्या कोई बेहतर तरीका है, तो सवाल खुद से पूछना है

क्या मैं अपने आप को सभी वस्तुओं के माध्यम से पुनरावृत्त पाता हूं, लेकिन उनमें से एक सबसेट पर काम कर रहा हूं?

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

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

आपको यह देखने के लिए प्रोफ़ाइल करना होगा कि क्या आपको बहुत अधिक प्रदर्शन प्राप्त हो रहा है।


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

8

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

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

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

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

गेम ऑब्जेक्ट को अपडेट करना

यहाँ गेम इंजन आर्किटेक्चर का एक अंश दिया गया है जिसे मैं पढ़ने की सलाह दूंगा:

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

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

यहाँ छवि विवरण दर्ज करें

खेल वस्तुओं का प्रतिपादन

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

यहाँ छवि विवरण दर्ज करें

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


4

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

यदि आप प्रदर्शन चाहते हैं, तो एक बड़ा वसा वैश्विक सी सरणी ऊपरी बाउंड (अनुभव से) होने वाला है।


2

मूल रूप से आप जो करना चाहते हैं, वह सूची बनाना है जैसा कि आपको उनकी आवश्यकता है। यदि आप सभी वस्तुओं को एक बार में भूरा कर देते हैं, तो बस उनकी सूची काम आ सकती है। लेकिन इसके लायक होने के लिए आपको उनमें से हजारों की आवश्यकता होगी, और कई 10,000 चीजें ऐसी हैं जो इलाके नहीं हैं । अन्यथा आपकी सूची से सबकुछ भ्रामक और इलाके की वस्तुओं को बाहर निकालने के लिए "अगर" का उपयोग करना काफी तेजी से पर्याप्त है।

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

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

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

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

दूसरे शब्दों में, बस वही करो जो आप कर रहे हैं। आपकी सबसे बड़ी सीमा शायद आपका अपना समय है, और आप इसका सबसे अच्छा उपयोग कर रहे हैं।


जब तक आप अक्सर बीच से सामान नहीं जोड़ते या हटाते हैं, तब तक मुझे नहीं लगता कि लिंक्ड लिस्ट किसी भी आकार में किसी सरणी को बेहतर बनाएगी।
ज़ैन लिंक्स

@ZanLynx: और फिर भी। मुझे लगता है कि नए रनटाइम अनुकूलन से सरणियों को बहुत मदद मिलती है - ऐसा नहीं है कि उन्हें इसकी आवश्यकता थी। लेकिन अगर आप बार-बार और तेज़ी से मेमोरी के बड़े हिस्से को आवंटित और मुक्त करते हैं, जैसा कि बड़े सरणियों के साथ हो सकता है, तो आप कचरा कलेक्टर को समुद्री मील में बाँध सकते हैं। (स्मृति की कुल मात्रा यहां भी एक कारक है। समस्या ब्लॉकों के आकार, मुफ्त की आवृत्ति और आवंटित, और उपलब्ध स्मृति का एक कार्य है।) विफलता अचानक होती है, जिसमें प्रोग्राम लटका या दुर्घटनाग्रस्त होता है। आमतौर पर बहुत सारी मुफ्त मेमोरी होती है; जीसी सिर्फ इसका इस्तेमाल नहीं कर सकता। लिंक्ड सूचियाँ इस समस्या से बचती हैं।
राल्फचिनपिन

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

हाँ, लेकिन यहां तक ​​कि एक सरणी में, क्या आप सिर्फ वस्तुओं को संकेत नहीं दे रहे हैं? (जब तक कि यह एक कण प्रणाली या कुछ के लिए एक अल्पकालिक सरणी नहीं है।) यदि ऐसा है, तो अभी भी बहुत सारे कैश मिस होंगे।
टोड लेहमैन

1

मैंने साधारण खेलों के लिए कुछ इसी तरह की विधि का उपयोग किया है। निम्न स्थितियों के सत्य होने पर एक सरणी में सब कुछ संग्रहीत करना बहुत उपयोगी है:

  1. आपके पास छोटी संख्या या गेम की अधिकतम ज्ञात वस्तुएं हैं
  2. आप प्रदर्शन पर सादगी का समर्थन करते हैं (जैसे: अधिक अनुकूलित डेटा संरचनाएं जैसे कि पेड़ परेशानी के लायक नहीं हैं)

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

बूलियन का उद्देश्य निर्माण और विलोपन कार्यों को गति देना है। जब वे सिमुलेशन से हटाए जाते हैं तो गेम ऑब्जेक्ट्स को नष्ट करने के बजाय, मैं बस "जीवित" ध्वज सेट करूंगा false

वस्तुओं पर गणना करते समय, कोड सरणी के माध्यम से लूप करेगा, "जीवित" के रूप में चिह्नित वस्तुओं पर गणना कर रहा है, और केवल "जीवित" चिह्नित वस्तुओं को गाया जाता है।

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

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

यह मेरी पहली पोस्ट है! मुझे आशा है कि यह आपके प्रश्न का उत्तर देगा!


पहिला पद! वाह!
तिली

0

यह स्वीकार्य है, हालांकि असामान्य है। "तेज़" और "अधिक कुशल" जैसे शब्द सापेक्ष हैं; आम तौर पर आप गेम ऑब्जेक्ट्स को अलग-अलग श्रेणियों में व्यवस्थित करेंगे (इसलिए गोलियों के लिए एक सूची, दुश्मनों के लिए एक सूची, आदि) प्रोग्रामिंग कार्य को और अधिक संगठित करने के लिए (और इस प्रकार अधिक कुशल) लेकिन यह ऐसा नहीं है कि कंप्यूटर सभी वस्तुओं के माध्यम से तेजी से लूप करेगा ।


2
अधिकांश XNA खेलों के संदर्भ में पर्याप्त है, लेकिन आपकी वस्तुओं को व्यवस्थित करना वास्तव में उनके माध्यम से तेजी से पुनरावृत्ति कर सकता है: आपके सीपीयू के निर्देश और डेटा कैश को हिट करने के लिए एक ही प्रकार की वस्तुओं की अधिक संभावना है। खासतौर पर कंसोल्स में कैश मिस महंगा होता है। उदाहरण के लिए Xbox 360 पर, एक L2 कैश मिस में आपको ~ 600 चक्र खर्च होंगे। वह मेज पर बहुत प्रदर्शन कर रहा है। यह एक ऐसा स्थान है जहां प्रबंधित कोड का मूल कोड से अधिक लाभ होता है: समय के साथ-साथ आवंटित वस्तुओं को स्मृति में भी पास किया जाएगा, और कचरा संग्रह (संघनन) के साथ स्थिति में सुधार होता है।
क्रॉनिक गेम प्रोग्रामर

0

आप एकल सरणी और ऑब्जेक्ट कहते हैं।

इसलिए (आपके कोड को देखे बिना) मैं अनुमान लगा रहा हूं कि वे सभी 'uberGameObject' से संबंधित हैं।

तो शायद दो समस्याएं।

1) आपके पास एक 'ईश्वर' वस्तु हो सकती है - सामान का टन, जो वास्तव में खंडित नहीं करता है कि यह क्या करता है या है।

2) आप इस सूची और टाइप करने के लिए कास्टिंग के माध्यम से पुनरावृति करते हैं? या प्रत्येक को अनबॉक्स करना। इसमें बड़ा प्रदर्शन दंड है।

अलग-अलग प्रकार (गोलियों, बुरे लोगों, आदि) को अपने स्वयं के टाइप किए गए सूचियों में तोड़ने पर विचार करें।

List<BadGuyObj> BadGuys = new List<BadGuyObj>();
List<BulletsObj> Bullets = new List<BulletObj>();

 //Game 
OnUpdate(gameticks gt)
{  foreach (BulletObj thisbullet in Bullets) {thisbullet.Update();}  // much quicker.

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

0

मैं सामान्य एकल सूची और प्रत्येक ऑब्जेक्ट प्रकार के लिए अलग-अलग सूचियों के बीच कुछ समझौता कर सकता हूं।

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

दृष्टिकोण के लाभ:

  • वस्तुओं का टंकण संगठन ( AllObjectsListअद्यतन पर कास्टिंग के साथ नहीं )
  • सूची लॉगिक्स पर आधारित होती हैं, न कि वस्तु कक्षाओं पर
  • संयुक्त क्षमताओं वाली वस्तुओं के साथ कोई समस्या नहीं है ( MegaAirHumanUnderwaterObjectइसके प्रकार के लिए नई सूची बनाने के बजाय संबंधित सूचियों में डाला जाएगा)

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.