परिचय
इकाई घटक प्रणाली एक वस्तु-उन्मुख वास्तुकला तकनीक है।
ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के समान शब्द का कोई सार्वभौमिक सर्वसम्मति नहीं है। हालांकि, यह स्पष्ट है कि इकाई-घटक प्रणाली विशेष रूप से विरासत के एक वास्तुशिल्प विकल्प के रूप में अभिप्रेत है । एक वस्तु क्या है , यह व्यक्त करने के लिए वंशानुगत पदानुक्रम स्वाभाविक हैं , लेकिन कुछ प्रकार के सॉफ़्टवेयर (जैसे गेम) में, आप यह व्यक्त करेंगे कि कोई वस्तु क्या करती है ।
यह "वर्गों और वंशानुक्रम" की तुलना में एक अलग ऑब्जेक्ट मॉडल है जिसमें से आप C ++ या जावा में काम करने के सबसे अधिक आदी हैं। इकाइयाँ वर्ग की तरह ही अभिव्यंजक हैं, जैसे जावास्क्रिप्ट या स्व-रूप में प्रोटोटाइप। इन सभी प्रणालियों को एक दूसरे के संदर्भ में लागू किया जा सकता है।
उदाहरण
आइए कहते हैं कि Playerके साथ एक इकाई है Position, Velocityऔर KeyboardControlledघटक है, जो स्पष्ट बातें करते हैं।
entity Player:
Position
Velocity
KeyboardControlled
हम जानते हैं Positionसे प्रभावित किया जाना चाहिए Velocity, और Velocityसे KeyboardControlled। सवाल यह है कि हम उन प्रभावों को कैसे मॉडल करना चाहते हैं।
एंटिटीज, कंपोनेंट्स और सिस्टम्स
मान लीजिए कि घटकों का एक दूसरे से कोई संदर्भ नहीं है; एक बाहरी Physicsप्रणाली सभी Velocityघटकों का पता लगाती है और Positionसंबंधित इकाई को अपडेट करती है; एक Inputसिस्टम सभी KeyboardControlledघटकों का पता लगाता है और अद्यतन करता है Velocity।
Player
+--------------------+
| Position | \
| | Physics
/ | Velocity | /
Input | |
\ | KeyboardControlled |
+--------------------+
यह मापदंड को संतुष्ट करता है:
सिस्टम अब घटनाओं को संभालने और घटकों द्वारा वर्णित व्यवहार को लागू करने के लिए जिम्मेदार हैं । वे संस्थाओं के बीच बातचीत को संभालने के लिए भी जिम्मेदार हैं, जैसे टकराव।
संस्थाओं और घटकों
हालांकि, लगता है कि घटकों कर एक-दूसरे के लिए संदर्भ की है। अब इकाई बस एक निर्माता है जो कुछ घटक बनाता है, उन्हें एक साथ बांधता है, और उनके जीवनकाल का प्रबंधन करता है:
class Player:
construct():
this.p = Position()
this.v = Velocity(this.p)
this.c = KeyboardControlled(this.v)
इकाई अब इनपुट और अद्यतन घटनाओं को सीधे उसके घटकों में भेज सकती है। Velocityअद्यतनों पर प्रतिक्रिया देगा, और KeyboardControlledइनपुट पर प्रतिक्रिया देगा। यह अभी भी हमारे मानदंडों को संतुष्ट करता है:
यहां घटक इंटरैक्शन स्पष्ट हैं, सिस्टम द्वारा बाहर से नहीं लगाए गए हैं। एक व्यवहार का वर्णन करने वाले डेटा (वेग की मात्रा क्या है?) और इसे लागू करने वाले कोड (वेग क्या है?) युग्मित हैं, लेकिन एक प्राकृतिक तरीके से। डेटा को व्यवहार के मापदंडों के रूप में देखा जा सकता है। और कुछ घटक बिल्कुल भी कार्य नहीं करते हैं - एक जगह में होनेPosition का व्यवहार है ।
सहभागिता को इकाई के स्तर पर ("जब एक Playerटकराता है Enemy...") या व्यक्तिगत घटकों के स्तर पर नियंत्रित किया जा सकता है ("जब एक इकाई एक इकाई के साथ Lifeटकराती है Strength...")।
अवयव
इकाई के मौजूद होने का क्या कारण है? यदि यह केवल एक निर्माता है, तो हम इसे घटकों के एक सेट को वापस करने वाले फ़ंक्शन के साथ बदल सकते हैं। यदि हम बाद में संस्थाओं को उनके प्रकार से क्वेरी करना चाहते हैं, तो Tagहमारे पास बस एक घटक हो सकता है जो हमें ऐसा करने देता है:
function Player():
t = Tag("Player")
p = Position()
v = Velocity(p)
c = KeyboardControlled(v)
return {t, p, v, c}
बातचीत को अब अमूर्त प्रश्नों द्वारा नियंत्रित किया जाना चाहिए , पूरी तरह से इकाई प्रकारों से घटनाओं को हटाने के लिए। क्वेरी करने के लिए कोई और अधिक इकाई प्रकार नहीं हैं - Tagगेम लॉजिक की तुलना में डिबगिंग के लिए संभवतः मनमाने ढंग से डेटा का उपयोग किया जाता है।
निष्कर्ष
संस्थाएँ फ़ंक्शंस, नियम, अभिनेता या डेटाफ़्लो कॉम्बिनेटर नहीं हैं। वे संज्ञाएं हैं जो ठोस घटना को मॉडल करते हैं - दूसरे शब्दों में, वे वस्तुएं हैं। जैसा कि विकिपीडिया कहता है- इकाई-घटक प्रणाली सामान्य वस्तुओं के मॉडलिंग के लिए एक सॉफ्टवेयर आर्किटेक्चर पैटर्न है।