हैलो, हाबरा!
जावास्क्रिप्ट में गेम विकसित करते समय, कई ऑब्जेक्ट्स बनाने के लिए अक्सर आवश्यक होता है। इसे सही ढंग से कैसे किया जाए और कोड में नहीं डूबने के बारे में, मैंने एक महीने पहले मिन्स्क के फ्रंटेंड देव कॉन्फ में बात की थी। शायद रिपोर्ट उन लोगों के लिए दिलचस्प होगी जो सम्मेलन में नहीं थे और कई ऑब्जेक्ट्स बनाने की समस्या का सामना कर रहे थे, या जो एचटीएमएल गेम के डेवलपर्स हैं।



चित्रों के साथ कटौती पाठ के तहत।

कक्षाएं और कारखाने

जैसा कि ऊपर उल्लेख किया गया है, खेल बनाते समय, विभिन्न प्रकार की वस्तुओं को बनाना आवश्यक हो जाता है। इसे प्राप्त करने के लिए, प्रोटोटाइप वंशानुक्रम का उपयोग किया जाता है। एक क्लासिक वर्ग इस दृष्टिकोण के साथ कैसा दिखता है:

function animal() { ... } animal.prototype.left = function() { ... } animal.prototype.right = function() { ... } 

आप इसे और इसी तरह के उदाहरण जावास्क्रिप्ट में OOP का वर्णन करने वाली कई पुस्तकों में पा सकते हैं। यही सिद्धांत अधिकांश एमवीसी रूपरेखाओं की नकल करता है। लेकिन क्या करना है जब हमें विभिन्न वर्गों की कई वस्तुओं को प्राप्त करने की आवश्यकता होती है? ऊपर वर्णित दृष्टिकोण के साथ, हमें कई कक्षाएं बनानी होंगी। परिणामस्वरूप, हमें परियोजना के बाद के समर्थन के साथ कठिनाइयाँ हो सकती हैं, बग ढूंढना और यह समझना कि यह कैसे काम करता है। दूसरों से कुछ वस्तुओं के आश्रित वंशानुक्रम की अंतहीन श्रृंखलाएँ बनाई जाती हैं। इस स्थिति से बाहर का रास्ता कारखाने का उपयोग करना है।

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

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

 var properties = { speed: { x: 0, y: 0 limit: { x: 10, y: 10 } }, acceleration: { x: 0, y: 0 }, live: { health: 100, killing: 0, level: 0 } }; 

 var prototypes = { left: function() { ... }, right: function() { ... } }; 

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

 var objectA = factory([ "physics", "live" ], [ "left" ]); var objectB = factory([ "live", "acceleration" ], [ "right" ]); 

फैक्ट्री में क्या होगा? निम्नलिखित के बारे में:

 var object = {}; //   for(var name in properties) { object[name] = properties[name]; } //   for(var method in prototypes) { object.prototype[method] = prototype[method]; } 

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

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

 var classList = { ... block: { _properties: [ //  ,    "skin", "dimensions", "physics", "coordinates", "type" ], _prototypes: [], //  ,    _common: { //     _properties: { move: false //  move     false } }, floor: { //       roughness: 0.37 //     }, gold: { roughness: 0.34 }, sand: { roughness: 0.44 //   ,    , }, //    water: { roughness: 0.25 } } }; 

कक्षाओं और वस्तुओं की समान सूची होने से, हम स्वचालित रूप से एक एपीआई भी बना सकते हैं। उदाहरण के लिए:

 block.gold(); //    block.sand(); //    block.water(); //    

इस प्रकार, हमें एक कारखाना मिला, जिसका कोड आकार खेल में वस्तुओं की संख्या और विविधता की परवाह किए बिना बदल जाता है और JSON प्रकार की तीन सूचियाँ:

• संपत्ति की सूची
• विधि सूची
• इन वर्गों की कक्षाओं और वस्तुओं की सूची

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

उदाहरण संपत्ति प्रलेखन फ़ाइल:

 var properties = { physics: { speed: { x: "   X", y: "   Y", limit: { x: "    X,     .", y: "    Y,     ." } }, acceleration: { x: "    X.   ...", y: "    Y.   ..." }, }, live: { health: "  .", killing: "   .", level: "  ." } }; 

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



कैसे सुनिश्चित करें कि हमारे कारखाने ठीक से काम कर रहा है?

ऐसा करने के लिए, हमें कई ऑब्जेक्ट्स बनाने, डिबगर चलाने और मेमोरी में ऑब्जेक्ट्स के गुणों और विधियों के पतों को देखना होगा।

• सभी गुणों के पते अलग-अलग होने चाहिए, क्योंकि वे प्रत्येक वस्तु के लिए अद्वितीय हैं।
• सभी विधियों के पते मेल खाने चाहिए, क्योंकि विधियाँ सभी वस्तुओं के लिए सामान्य हैं।

इंटरफ़ेस मानकीकरण

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

समस्या:

एक निश्चित खेल चरित्र और उसके आसपास की दुनिया है। जब कोई खिलाड़ी "उपयोग" बटन रखता है, तो कम से कम दो स्थितियां संभव हैं:

• चरित्र हथियार के पास है। इस मामले में, उसे हथियार को एक बैग में रखना चाहिए।
• चरित्र परिवहन के पास है। इस मामले में, उसे वाहन चलाना चाहिए।

समाधान:

• जब आप उपयोग बटन दबाते हैं, तो हम अपने चरित्र के पास सभी वस्तुओं की तलाश करते हैं।
• अगला, हम वस्तुओं पर पुनरावृति करना शुरू करते हैं, निकटतम से शुरू करते हैं और जांचते हैं कि क्या उनके पास उपयोग () विधि है।
• यदि इस विधि के साथ कोई वस्तु मिलती है, तो हम अपने चरित्र को वहां फेंक देते हैं और खोज पूरी करते हैं।

यह स्पष्ट है कि हथियारों और वाहनों के लिए उपयोग () विधि अलग होगी, लेकिन कारखाने में प्रोटोटाइप विरासत के समय इसे कैसे लागू किया जाए?

इसका उत्तर बहुत सरल है। यह सूची में है या नहीं, यह जांचने के लिए एक विधि नाम देने से पहले एक प्रतिस्थापन सूची बनाना आवश्यक है। उदाहरण के लिए:

 //       var replaceList = { ... weapon: "use", transport: "use" } //  ,      for(var method in prototypes) { var name = replaceList[method] || method; object.prototype[name] = prototype[method]; } 

इस प्रकार, इस तथ्य के बावजूद कि हथियार को "हथियार", और परिवहन - "परिवहन" विरासत में मिला है, प्रोटोटाइप वस्तुओं में केवल एक उपयोग विधि होगी, जिसके पीछे प्रत्येक वस्तु अपने स्वयं के कार्यों को छिपाएगी। ऐसी बहुरूपता।

वस्तुओं को कैसे सहेजना और लोड करना है

अब जबकि हमारे पास विभिन्न वस्तुओं के एक समूह के साथ एक बड़ी दुनिया है (Minecraft की कल्पना करें), यह निम्न समस्या को हल करने का समय है - बचाने / लोड कार्यों के कार्यान्वयन।

पहली नज़र में, सब कुछ सरल है। क्योंकि हमारे पास कई वस्तुएं हैं, हम उन्हें एक स्ट्रिंग में बदल सकते हैं (JSON.stringify), लेकिन दो समस्याएं हैं:

• वस्तुओं के कई रिश्ते हो सकते हैं।
• प्रोटोटाइप चेन खो जाएगा

हम प्रत्येक समस्या के समाधान का अलग से विश्लेषण करेंगे।

वस्तुओं के भंडारण पर प्रतिबंध।



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

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

या दूसरा उदाहरण:

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

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

प्रोटोटाइप चेन को पुनर्स्थापित करें।



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

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