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