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