सही ढंग से प्रोग्राम करने योग्य। हम बहुरूपता का उपयोग करते हैं। खेल पात्रों का सामान्य तर्क

Unity3D। हम OOP के लाभ का उपयोग करते हैं। बहुरूपता

चेतावनी!

मैं आपको तुरंत चेतावनी देना चाहता हूं, लेख पर टिप्पणियों को पढ़ें, वहां कुमोइकैरो ने लेख में पेश की गई समस्याओं को हल करने के लिए एक अधिक सही दृष्टिकोण का सुझाव दिया।

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

लेख का उद्देश्य OOP के सभी आकर्षण की शक्ति और असीमित उपयोगिता को पहचानना है। विशेष रूप से, पॉलीमारॉफिसम। इसके अलावा, हम कई अन्य महत्वपूर्ण मुद्दों पर बात करेंगे।

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

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

यह लेख यूनिटी 3 डी की समझ रखने वाले लोगों के लिए है। यदि आपके पास यह दृश्य नहीं है, तो मैं इन लेखों को पढ़ने की अत्यधिक सलाह देता हूं:

1) बहुत अच्छे लेख: habrahabr.ru/post/112287 , habrahabr.ru/post/113859
दूसरे लेख में, जेएस में लिपियों के उदाहरण। मुझे लगता है कि सी # में अनुवाद करने में कोई समस्या नहीं होगी, भले ही आप जेएस और सी # दोनों के लिए नए हों। केवल एक चीज मैं कहूंगा कि जेएस में लाइन:

bull_clone = Instantiate(bullet, transform.position, transform.rotation); 

C # में यह इस तरह दिखेगा:

 bull_clone = (GameObject)Instantiate(bullet, transform.position, transform.rotation); 

और जेएस में इस तरह की एक लाइन:

 var ml = GameObject.Find("Player").GetComponent(MouseLook); 

C # में यह इस तरह दिखेगा:

 GameObject ml = GameObject.Find("Player").GetComponent<MouseLook>(); 

2) अनुच्छेद: habrahabr.ru/post/141362 साइट पर इस लेख का एक निरंतरता भी है। उन्हें "यूनिटी 3 डी" कहा जाता है। एकता 3 डी छात्र (B00-B16) से सबक »केवल 4 लेख। फिलहाल, कम से कम। शीर्ष दाईं ओर साइट पर एक खोज इंजन है। मुझे लगता है कि आप इसे संभाल सकते हैं।

3) habrahabr.ru/post/148410 यह पढ़ना और समझना भी आवश्यक है। इस लेख का एक और हिस्सा है। साइट पर खोज इंजन आपको फिर से मदद करेगा।

4) यह निर्देशिका habrahabr.ru/post/128711 , habrahabr.ru/post/128948 की तरह कुछ है।

5) इस मंच पर कई दिलचस्प लेख हैं। आप चाहें तो खुद देख लें।
So. आपने वह सब कुछ सीखा है जो आपने पढ़ा है, प्रयोग किया है, शायद पहले से ही एक छोटा खेल बनाया है। शायद थोड़ा नहीं। यह बुरा है अगर आप सिर्फ इन लेखों को पढ़ते हैं, लेकिन खुद कुछ भी नहीं लिखते हैं। अभ्यास करें और फिर से अभ्यास करें

लेकिन पहले, कुछ सवालों पर विचार करें। (बस मामले में)

लेख का पहला आधा प्रदर्शन प्रयोजनों के लिए है। कोड को फिर से लिखना आवश्यक नहीं है।
मैं निम्नलिखित शब्दों को समानार्थक शब्द के रूप में उपयोग करता हूं: स्क्रिप्ट वर्ग

क्लास, क्लास

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

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

कैशिंग

विकिपीडिया से: कैशिंग कार्य परिणाम -

कई कार्यक्रम कहीं न कहीं मध्यवर्ती या काम के सहायक परिणाम लिखते हैं, इसलिए उन्हें हर बार उनकी गणना करने की आवश्यकता नहीं है। यह काम को गति देता है, लेकिन अतिरिक्त मेमोरी (रैम या डिस्क) की आवश्यकता होती है।

इस लिपि पर विचार करें। उसके बारे में क्या बुरा है? सब ठीक लगने लगा है। एक वस्तु 10 इकाइयों प्रति सेकंड की निरंतर गति से वामपंथ की ओर बढ़ती है। यह Time.deltaTime के लिए धन्यवाद है कि एक समान आंदोलन होता है, जो किसी विशेष कंप्यूटर पर वर्तमान प्रदर्शन पर निर्भर नहीं करता है।

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

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

आइए एक दो और उदाहरण देखें कि किन चीजों को कैश किया जाना चाहिए:

कोड में टिप्पणियों को ध्यान से पढ़ें

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



यह दाईं ओर कहता है कि यह एक वर्ग है, और बाईं ओर का आइकन भी विशेष है। (लाल रंग में परिचालित)
लेकिन आप इसे कैश नहीं कर सकते।

चूंकि स्थिति वर्ग का उदाहरण नहीं है। यह एक वेक्टर 3 संरचना है

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

 Public Vector3 aaa; aaa = transform.position; //    transform.position.      aaa    transform.position.    ( )     , .         . 

आपको न केवल वस्तुओं पर लटकी हुई लिपियों को कैश करने की आवश्यकता है, बल्कि स्वयं वस्तुओं को भी।

आगे के उदाहरणों में, सब कुछ कैश हो जाएगा, इसलिए आप उदाहरणों को समझेंगे।

MOBA (कार्टर) की सामान्य अवधारणा

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

• स्टैंडबाय व्यवहार (पास में कोई खिलाड़ी नहीं है और भीड़ कुछ नहीं करती (या करती है। यह खेल के विशिष्ट विचार पर निर्भर करता है))। आप इस मोड को "लक्ष्य खोज" भी कह सकते हैं
• व्यवहार में "मैं लक्ष्य देखता हूं, मैं मार सकता हूं, करीब पहुंच सकता हूं" (एक नए लक्ष्य पर दौड़ें)
• व्यवहार "पास में लक्ष्य पर हमला किया जाना चाहिए" मोड (हमला)

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

ये सभी स्क्रिप्ट चरित्र की गतिशीलता (भीड़) को नियंत्रित कर सकते हैं। वे इसे स्वयं प्रबंधित नहीं करते हैं, लेकिन मोटर नामक एक मध्यवर्ती स्क्रिप्ट के माध्यम से। चरित्र को नियंत्रित करने के लिए मोटर-इन-लॉ के कई तरीके आवश्यक हैं। उदाहरण के लिए:

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

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



वैसे, मैं आपको सार्वजनिक याद दिलाता हूं - इसका मतलब है कि घोषित चर (विधि, आदि) सामान्य रूप से सभी लिपियों के लिए उपलब्ध होगा। केवल स्क्रिप्ट के अंदर ही उपलब्ध निजी

MobHp स्क्रिप्ट पर विस्तार से विचार करें। चरित्र दिखाई देता है और तुरंत 100 इकाइयों का स्वास्थ्य होता है। जब कोई चरित्र क्षति प्राप्त करता है (क्षति को प्राप्त करना मुख्य स्क्रिप्ट द्वारा मॉनिटर किया जाता है और स्वयं MobHp नहीं), तो मुख्य स्क्रिप्ट MobHp.SetDamage (फ्लोट क्षति) विधि को कॉल करता है। यह विधि या तो सही है या गलत है। अगर सच लौटा दिया जाता है, तो भीड़ क्षति से बच जाती है। और मुख्य स्क्रिप्ट कार्य करना जारी रखती है। अगर झूठ लौटता है, तो भीड़ मर जाती है। मृत्यु के बाद भीड़ का क्या होता है, मुख्य लिपि की परवाह नहीं की जाती है। उसे यह पता नहीं है। हमारे मामले में, मृत्यु के बाद, एक ध्वनि फ़ाइल खेली जाती है (चरित्र की ध्वनि मर जाती है) और 5 सेकंड के बाद चरित्र गायब हो जाएगा (चित्र देखें)। मुख्य स्क्रिप्ट की भूमिका सरल है। यदि गलत है, तो यह सभी व्यवहार स्क्रिप्ट को निष्क्रिय कर देता है। चरित्र की मोटर को निष्क्रिय करता है। वह सब कुछ बंद कर देगा। यही है, भीड़ जम जाएगी, मरने वाली भीड़ की आवाज बजाई जाएगी, और फिर यह गायब हो जाएगी। बेशक, आप MobHp स्क्रिप्ट में टुकड़ों की पीढ़ी को जोड़ सकते हैं, जो चरित्र के एनीमेशन को जमीन पर गिर रहा है। कुछ भी आप चाहते हैं। सुंदरता यह है कि MobHp स्क्रिप्ट पूरी तरह से स्वतंत्र है। यदि मुख्य स्क्रिप्ट और MobHp को अलग-अलग लोगों द्वारा प्रोग्राम किया जाता है, तो सभी को समन्वित कार्य के लिए जानना आवश्यक है कि चरित्र को MobHp.SetDamage (फ्लोट डीफैमेज) विधि के माध्यम से नुकसान होता है। और अगर विधि झूठी है, तो भीड़ मर चुकी है। वह सब है! कोई अनावश्यक जानकारी नहीं। और अगर MobHp का निर्माता स्क्रिप्ट की सामग्री को बदलना चाहता है, तो यह मुख्य स्क्रिप्ट को प्रभावित नहीं करता है!

महामहिम POLYMORPHISM

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

एक स्विच की कल्पना करो। सामान्य स्विच। जो आपके कमरे में प्रकाश चालू (बंद) करता है। या वह पंखे को चालू करता है? या शायद वह एक खराद शुरू करता है। लेकिन क्या कोई पारंपरिक स्विच परमाणु बम को ट्रिगर कर सकता है। शायद यह स्पष्ट है कि स्विच को परवाह नहीं है कि क्या चालू करना है (बंद)। यह सिर्फ संपर्क खोलता है। वह कहीं बाहर ऊर्जा देता है। वह परवाह नहीं करता है

अब एक टैंक शेल की कल्पना करें। यह उड़ता है, गिरता है और फट जाता है, जिससे आसपास की हर चीज को नुकसान होता है। वह परवाह नहीं करता है कि आसपास क्या है। वह सिर्फ परवाह नहीं करता है उसे पता नहीं है कि उसके आसपास क्या है, लेकिन, फिर भी, वह नुकसान करता है।

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

आप इस तरह के एक विशिष्ट टैग के साथ सभी वस्तुओं की एक सरणी प्राप्त कर सकते हैं

 GameObject[] allMobs= GameObject.FindGameObjectsWithTag ("Mob" ); //    //     

निश्चितता के लिए, हमारी मुख्य लिपि को MyBehaviour कहा जाना चाहिए

और अब हम सभी मॉब के माध्यम से सॉर्ट करते हैं और उन पर नुकसान पहुंचाते हैं (कृपया ध्यान दें। हमने प्रस्तुत किया है कि मुख्य स्क्रिप्ट (MyBehaviour) में एक विधि MyBehaviour.SetDamage (फ्लोट डैमेज) है, जो बदले में MobHp.SetDamage (फ्लोट डैमेज) विधि को MobHp स्क्रिप्ट पर कॉल करता है। स्क्रिप्ट चरित्र पर लटकी (भीड़)
खोल पर स्क्रिप्ट में कोड।

 foreach ( GameObject mob in allMob ) //      { mob.GetComponent<MyBehaviour>().SetDamage(50); //     SetDamage } 

इस उदाहरण में, प्रक्षेप्य 50 क्षति का सौदा करता है।
सब कुछ बहुत अच्छा है! यह काम करेगा। लेकिन अगर हम TWO प्रकार के कई भीड़ चाहते हैं? दूसरे प्रकार में, मुख्य स्क्रिप्ट को अलग तरीके से लागू किया जा सकता है। उदाहरण के लिए, एक रोबोट और एक बंदूक। उनका बहुत अलग व्यवहार है। उन्होंने अलग तरह से व्यवहार को लागू किया है "देखें, मैं मार सकता हूं, करीब पहुंच सकता है" मोड (हम एक नए लक्ष्य के लिए दौड़ते हैं)। बंदूक में एक भी नहीं है। इस प्रकार, टॉवर में, मुख्य स्क्रिप्ट को MyBehaviour2 कहा जाएगा (विभिन्न लिपियों को अलग-अलग कहा जाना चाहिए), और सभी व्यवहार लिपियों को अलग-अलग कहा जाता है। और यहां तक ​​कि MobHp में एक अलग बंदूक है। MobHp2, उदाहरण के लिए, अपने तरीके से "बंदूक मरने" को लागू करता है (मामला मरने की ध्वनि और एनीमेशन को बदलने के लिए सीमित नहीं हो सकता है)। सभी मॉब और टावरों को नुकसान पहुंचाने के लिए एक टैंक शेल को अब कैसे व्यवहार करना चाहिए?

हमें टॉवर के लिए एक नया टैग पेश करने की आवश्यकता है। और शेल स्क्रिप्ट स्वयं फॉर्म लेगी:

 //   GameObject[] allMobs= GameObject.FindGameObjectsWithTag ("Mob" ); //    //     foreach ( GameObject mob in allMob )//     { mob.GetComponent<MyBehaviour>().SetDamage(50); //     } //   GameObject[] allTower= GameObject.FindGameObjectsWithTag ("Tower" ); foreach ( GameObject tower in allTower )//     { tower.GetComponent<MyBehaviour2>().SetDamage(50); //     } 

इस दृष्टिकोण के नुकसान क्या हैं। जाहिर है, शेल स्क्रिप्ट मॉब के प्रकारों की संख्या पर निर्भर करती है। इस प्रकार, यदि आप एक प्रकार की भीड़ जोड़ना चाहते हैं, तो आपको शेल स्क्रिप्ट में आना होगा और इसे अपग्रेड करना होगा। अब कल्पना करें कि गेम में 500 प्रकार के मॉब हैं। शेल स्क्रिप्ट में कोड की लगभग 1,500 लाइनें होंगी। यह विचार करने योग्य है कि खेल में निश्चित रूप से कई दर्जन प्रकार के गोले होंगे। अपने लिए गिनो। यदि शेल स्क्रिप्ट एक व्यक्ति द्वारा किया जाएगा, और मोब्स और गन और अन्य पात्रों (MyBehaviour, MyBehaviour2, MyBehaviour3, आदि) की मुख्य स्क्रिप्ट एक और व्यक्ति है, तो समन्वय कार्य के लिए उन्हें मॉब्स की संख्या और सटीक नाम (और शायद सामग्री) को जानना होगा। उनकी मुख्य लिपियों (कल्पना करें कि नाम MyBehaviNN नहीं होंगे, लेकिन RobotBehaviour, TowerBehaviour, MonsterBehaviour, TigerBehaviour, आदि)

चलो स्विच पर वापस जाते हैं, जो परवाह नहीं करता है कि यह क्या चालू करता है। यदि आपके पास खेल में 5 प्रकार के दरवाजे हैं, तो प्रत्येक को अपने स्वयं के स्विच (बटन) की आवश्यकता होगी। और यदि आप एक प्रकार का दरवाजा जोड़ना चाहते हैं, तो आपको एक बटन जोड़ना होगा या मौजूदा लोगों को अपग्रेड करना होगा। और अगर अलग-अलग लोग बटन और दरवाजे प्रोग्राम करते हैं, तो उन्हें सभी दरवाजों और बटन की सभी लिपियों के सभी नामों (और शायद सामग्री) को जानना होगा।

स्थिति बिल्कुल पात्रों के हथियारों के साथ समान है, कवच (यदि खेल पर उनका प्रभाव ताकत, गति, आदि में परिवर्तन तक सीमित नहीं है), किसी भी जटिल बातचीत वस्तुओं द्वारा।

बेशक, इस समस्या को हल करने के तरीके हैं। लेकिन मेरी राय में, सबसे सुरुचिपूर्ण और समझने में आसान, पॉलीमॉर्फ़िस्म है। मैं सख्त परिभाषा नहीं लिखूंगा, आप उन्हें स्वयं पा सकते हैं।

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

आप देखिये! MobHp, MonoBehaourour का उत्तराधिकारी है। MonoBehaviour MobHp के जनक हैं। माता-पिता को बृहदान्त्र के माध्यम से लिखा जाता है।
और अब चाल। एक नई खाली स्क्रिप्ट बनाएं, इसे NewMobHp कहें और इसके बजाय MonoBehaviour (स्क्रिप्ट में ही) MobHp लिखें (यही है, हमने संकेत दिया कि इस नए NewMobHp के जनक MonoBhaviour नहीं होंगे, लेकिन MobHp) (नीचे दी गई तस्वीर देखें)।
NewMobHp स्क्रिप्ट में, NewMobHp नाम के एक वेरिएबल को NewMobHp (एक छोटे अक्षर के साथ) नाम के साथ घोषित करें। इस बात से घबराए नहीं कि न्यूमोबएचपी स्क्रिप्ट ("स्क्रिप्ट" और "क्लास" हमारे लिए समानार्थी हैं) हमने उसी तरह के एक वैरिएबल को क्लास के रूप में घोषित किया। हाँ, एक वर्ग में उसी प्रकार के चर हो सकते हैं जैसे कि कक्षा। प्रारंभ में "newMobHp" लिखें और डॉट को दबाएं। यदि आपके पास एक सामान्य कोड संपादक है, तो यह कोड के इस स्थान पर आपके लिए उपलब्ध सभी तरीकों, गुणों आदि को दिखाएगा। चलिए शुरू करते हैं सेटडा ... मैजिक

और जादू !!! हमारे NewMobHp क्लास में एक MobMp क्लास की तरह एक NewMobHp .SetDamage (फ्लोट डैमेज) विधि है। हालाँकि स्क्रिप्ट अभी बनाई गई है और इसमें SetDamage (फ्लोट डैमेज) विधि की कोई घोषणा नहीं की गई है, लेकिन यह विधि पैरेंट क्लास में घोषित की गई है। यह हेरिटेज है। NewMobHp वर्ग को SetDamage (फ्लोट डैमेज) विधि विरासत में मिली है, क्योंकि यह MobHp में कीवर्ड पब्लिक के साथ घोषित किया गया था।

वैसे, संरक्षित और निजी के बीच क्या अंतर है? वह सब निजी विरासत में नहीं मिला है। वह सब जो विरासत में मिला है। इसलिए, यदि हम विश्व स्तर पर घोषित (सार्वजनिक) विधि या चर, आदि को विरासत में लेना चाहते हैं, तो कुछ भी करने की आवश्यकता नहीं है। यह पहले से ही विरासत में मिला है। यदि हम इस वर्ग के लिए एक स्थानीय चर प्राप्त करना चाहते हैं, तो निजी के बजाय हमें मूल वर्ग में संरक्षित लिखना होगा।
तो इस क्षण से मैं आदेश देता हूं, कोड! मेरे द्वारा बाद में लिखी जाने वाली हर चीज आपके द्वारा लिखी जानी चाहिए। प्रयोग, समझ, सामान कलम।

NewMobHp और अन्य स्क्रिप्ट मेरे काम आएंगी; हम उन्हें हटा देंगे (यदि आपने किया है)। वैसे, NewMobHp वर्ग न केवल MobHp का उत्तराधिकारी है, बल्कि MonoBehaviour का भी है। चूंकि MobHp MonoBehaviour वर्ग का उत्तराधिकारी है।

इस तरह: MonoBehaviour -> MobHp -> NewMobHp।

MobHp, NewMobHp के लिए तत्काल अभिभावक है।
ओपन यूनिटी, हम कोडिंग शुरू करते हैं! शायद कुछ स्पष्ट नहीं होगा, लेकिन जब हम एक छोटे से खेल के निर्माण के लिए आते हैं तो सब कुछ स्पष्ट हो जाएगा।

एक पिताजी MyScript बनाएँ। इसमें हम MyBehaviour स्क्रिप्ट बनाएंगे। यह सभी मॉब की सभी मुख्य लिपियों के लिए माता-पिता होगा (सामान्य तौर पर, सब कुछ जो जानता है कि नुकसान कैसे प्राप्त करें)। हम इसमें SetDamage मेथड बना सकते हैं। और भविष्य में, नई मुख्य स्क्रिप्ट इसे विरासत में मिलेंगी। और सभी मॉब में यह विधि होगी। लेकिन प्रत्येक प्रकार की भीड़ के लिए, क्षति प्राप्त करने की प्रक्रिया को विभिन्न तरीकों से लागू किया जा सकता है। प्रत्येक स्क्रिप्ट के लिए अलग तरीके से लागू की गई विधि को कैसे बनाया जाए?

POLYMORPHISM - मुझे नहीं पता कि इसे कैसे परिभाषा दी जाए। शायद आप खुद ही बाद में दे देंगे। हम एक उदाहरण के रूप में हर चीज पर करीब से नज़र डालेंगे। आइए इसे MyBehaviour में लिखें:

एक खाली SetDamage विधि। इसकी आवश्यकता क्यों है? हां, हमें उसकी जरूरत नहीं है। वर्चुअल कीवर्ड पर ध्यान दें (चित्र देखें)।इसका मतलब यह है कि इस विधि को अन्य लिपियों में ओवरराइड किया जा सकता है जो MyBehaviour स्क्रिप्ट के वारिस होंगे। यही है, वे इसे विरासत में लेते हैं, लेकिन इसे अपने तरीके से लागू करते हैं। अब हम एक MobBehaviour स्क्रिप्ट बनाते हैं:

और इसलिए हम यहाँ क्या होता है का विश्लेषण करेंगे:
1- हमने स्पष्ट रूप से संकेत दिया है कि MobBehaviour MyBehaviour वर्ग का उत्तराधिकारी है
2- मैं ओवरराइड शब्द लिखता हूं, एक स्पेस डालता हूं और विजुअल स्टूडियो खुद बताता है कि हम REDEFINE कर सकते हैं। जैसा कि आप देख सकते हैं कि सेटडैमेज (फ्लोट क्षति) है, तो हमें इसकी आवश्यकता है। अन्य सभी तरीके MyBehaviour की तुलना में पैरेंट स्क्रिप्ट में घोषित किए गए तरीके हैं। उदाहरण के लिए ToString ()। हम ToString () और प्रोग्राम को ओवरराइड कर सकते हैं कि यह विधि हमारे MobBehaviour वर्ग के लिए कैसे काम करती है। लेकिन हमें इसकी आवश्यकता नहीं है। SetDamage (फ़्लोट क्षति) का चयन करें और देखें (चित्रा 3 में आंकड़ा) कि यह विधि मूल रूप से MyBehaviour में परिभाषित की गई थी (अर्थात, यह MyBehaviou वर्ग से विरासत में मिली है)। आप देख सकते हैं कि कहाँ ToString () और अन्य परिभाषित हैं। अब लाइन सेटडैमेज (फ्लोट क्षति) का चयन करें, एंटर दबाएं और यही वह है जो विजुअल स्टूडियो ने खुद को आकर्षित किया है:

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

MobBehaviour से ब्रेक लें। आइए एक नई MyHp स्क्रिप्ट बनाएं।

यह एक स्क्रिप्ट है जिसमें से चरित्र के स्वास्थ्य के लिए जिम्मेदार सभी लिपियों को विरासत में मिलेगा।
दूसरी स्क्रिप्ट बनाते हैं। चलो इसे MobHp कहते हैं। हमने ऊपर इसकी जांच की।

पिछली बार की तरह, सेटडैमेज (फ्लोट क्षति) विधि के पुनर्वितरण में केवल ओवरराइड शब्द है। और यह इंगित किया जाता है कि वर्ग MyHp वर्ग का उत्तराधिकारी है। थोड़ा और मरने वाली भीड़ बदल गई। कोई आवाज़ नहीं है, भीड़ केवल 3 बार मौत से बढ़ जाएगी।

फिर से, MobBehaviour के बारे में सोचें। आइए इसे ऐसे बनाते हैं:

हमने SetDamfge (फ्लोट क्षति) विधि को फिर से घोषित किया। कृपया ध्यान दें कि इसHp को MyHp के रूप में घोषित किया गया है, हालांकि स्वास्थ्य स्क्रिप्ट को MobHp कहा जाता है। यहाँ यह पॉलीमॉर्फ़िस्म है। हम MobHp के साथ-साथ MyHp के साथ भी काम कर सकते हैं। हम MobHp वर्ग के एक उदाहरण के लिए MyHp प्रकार का एक चर असाइन कर सकते हैं, क्योंकि यह MyHp का उत्तराधिकारी है। इस प्रकार, MobBehaviour स्क्रिप्ट को ध्यान नहीं है कि MyHp वर्ग का उत्तराधिकारी इस HH चर में निहित है। मुख्य बात यह है कि इसHp में एक SetDamfge (फ्लोट क्षति) विधि है। और इसका उपयोग किया जा सकता है! हम MobHp स्क्रिप्ट को दूसरे (MyHp का वारिस भी) में बदल सकते हैं। और सब कुछ काम करेगा।

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

यह गेंद हमारी पहली भीड़ होगी। हम इस पर MobBehaviour और MobHp स्क्रिप्ट लटकाएंगे।

MobBehaviour स्क्रिप्ट में इस एचपी पर ध्यान दें (चित्र देखें)। अब वहाँ कुछ भी नहीं सौंपा गया है (कोई नहीं)। हालाँकि, शुरू में (MobBehaviour में प्रारंभ () प्रक्रिया में) MyHp (या इसके उत्तराधिकारी) के लिए यह पता
चलेगा। Get = GetComponent ();
तो, हमारे पास एक भीड़ है जिसे आप मार सकते हैं। सच है, इसे "स्फियर" कहा जाता है, लेकिन इससे कोई फर्क नहीं पड़ता। एक खिलाड़ी बनाना आवश्यक होगा जो मॉब में गेंदों की शूटिंग करेगा। चलो करते हैं।
मौजूदा कैमरा हटाएं। आइए पहले व्यक्ति नियंत्रक बनाएं (यह फ़ोल्डर्स में है, लेख की शुरुआत में संदर्भित पाठ याद रखें)। एक गेंद (छोटा) बनाएं, इसे रिगिबॉडी संलग्न करें। आइए इसे बुलेट कहते हैं और इसे MyPrefab नामक एक नए फ़ोल्डर में खींचें

यह हमारा भविष्य का संरक्षक है। वैसे, ताकि वह तेज गति से दीवारों के माध्यम से उड़ान न भरे, हम ऐसा करेंगे।

अब भौतिक इंजन कारतूस की गति को बाधित करेगा। यह संभवतः एक जटिल एल्गोरिथ्म है, इसलिए इंटरपोल को स्थापित करने के लिए यह सब कुछ लायक नहीं है। केवल तेज गति से चलने वाली वस्तुएं (बहुत तेज। वे जो आधे मीटर या एक से अधिक फ्रेम से उड़ सकती हैं)। विकिपीडिया पर पढ़ें कि प्रक्षेप और एक्सट्रपलेशन क्या हैं।
एक नई BulletScript स्क्रिप्ट बनाएं। यह एक कारतूस की पटकथा है।

जब आप कुछ हिट करते हैं, तो इस स्क्रिप्ट को इस चीज़ से MyBehaviour घटक (या इसके किसी भी उत्तराधिकारी) को मिलता है। और कॉल (अगर यह कुछ MyBehaviour है) SetDamfge (फ्लोट क्षति) विधि के साथ क्षति = 30। तो, एक कारतूस 30 नुकसान करता है। POLYMORPHISM के लिए धन्यवाद, कारतूस वास्तव में परवाह नहीं करता है, और जो MyBehaviour वारिस वह हमला करना चाहता है। अगर इस लिपि को लिखने के बाद भी हम अपने उत्तराधिकारी के साथ खेल में एक नए प्रकार की भीड़ को जोड़ते हैं, (उदाहरण के लिए, टॉवरबेहौर), कारतूस तब भी नुकसान करेगा जब वह इस नई भीड़ में पहुंच जाएगा। एक टैंक शेल का उदाहरण याद रखें। इस स्क्रिप्ट को कार्ट्रिज प्रीफैब तक खींचना न भूलें।

यह केवल खिलाड़ी को इन कारतूसों को शूट करने के लिए मजबूर करने के लिए रहता है। एक नया प्लेयरशूट स्क्रिप्ट बनाएँ

इसी तरह की एक स्क्रिप्ट बनाई गई थी और लेखों में से एक में विस्तार से वर्णन किया गया था, जो एक लिंक लेख की शुरुआत में है। केवल वह जेएस में था। आइए हम केवल मुख्य बिंदुओं पर ध्यान
केंद्रित करें : 1-कारतूस का प्रीफैब जिसे हम शूट करने जा रहे हैं,
2-प्रारंभिक कारतूस की गति,
शॉट्स के बीच 3-पॉज़,
4-कैमरा ट्रांसफ़ॉर्म, क्योंकि जब हम माउस को घुमाते हैं, तो यह
अंतिम शॉट के 5-टाइम,
6- कैमरा बदल कैश। ध्यान दें कि हमने यह कैसे किया। यह स्क्रिप्ट हमारे FirstPersonController पर लटकेगी। इसलिए, रूपांतरण के द्वारा (यदि आप इस शब्द को स्क्रिप्ट में लिखते हैं) का अर्थ है FirstPersonController रूपांतरण, कैमरा नहीं।

पैमाने पर ध्यान दें। पहले व्यक्ति नियंत्रक मेरे पास 1,1,1 का एक पैमाना है

यदि आपके पास वहां 100,100,100 हैं, तो आप या तो भीड़ या उसके भविष्य के आंदोलन को नोटिस नहीं कर सकते हैं।

हम सब ट्रांसफॉर्म के बीच खोज करेंगे (कोई कह सकता है कि बच्चे ट्रांसफॉर्म करते हैं। लेकिन क्लास के साथ वारिस के अर्थ में नहीं) कैमरा ट्रांसफॉर्म का उपयोग करके बदल जाता है। विंडचाइल्ड ("मेन कैमरा") विधि। यह विधि FirstPersonController उप-ऑब्जेक्ट के बीच ससुर को "मुख्य कैमरा" नाम से खोजेगी और उससे रूपांतरण प्राप्त करेगी। और हम इस ट्रांसफॉर्म को कैमराट्रेनफॉर्म वेरिएबल में कैश कर देते हैं।
7-अगर आखिरी शॉट से ज्यादा शूटपॉज पास हुआ है, तो आप शूट कर सकते हैं।
8-कारतूस की एक प्रति बनाएँ।
9-कठोर कारतूस प्राप्त करें।
10-कारतूस में गति जोड़ें।
11-शॉट का समय याद रखें।
हम इस स्क्रिप्ट को खिलाड़ी पर फेंकते हैं। जहां आवश्यक हो, कारतूस के प्रीफैब को खींचें

हम खेल शुरू करते हैं। हम भीड़ ढूंढते हैं। हम बाईं माउस बटन का उपयोग करके उस पर गोली मारते हैं। शॉट्स की गिनती। यह 4 हिट के साथ प्रफुल्लित होना चाहिए। कंसोल में "Mob is dead !!!" दिखाई दिया। भीड़ सूज जाती है और 5 सेकंड के बाद गायब हो जाती है।

भीड़ फूला हुआ है क्योंकि MobHp स्क्रिप्ट में हमने यह लिखा है Transform.localScale = new Vector3 (3, 3, 3)। यदि आपकी भीड़ पर्याप्त नहीं है, तो तीन बिंदुओं को बड़े मानों में बदलें। खैर, यहाँ हमने वही किया है जो आप शायद कर सकते थे। बहुरूपता की सुंदरता क्या है? लेकिन यहाँ बात है।एक और भीड़ पैदा करते हैं। एक बॉल भी। आइए उस पर एक नया मॉन्स्टरहैप स्क्रिप्ट डालें:

जैसा कि आप देख सकते हैं, यह मोबहैप स्क्रिप्ट से लगभग अलग नहीं है। सभी अंतर लाल रंग में रेखांकित हैं। हमने सामग्री को कैश किया, और स्वास्थ्य के आधार पर इसका रंग बदल दिया। यदि आप नहीं जानते कि आप कैसे रंग बनाना चाहते हैं, तो RGB रंग मॉडल के बारे में इंटरनेट देखें।

चलो हमारे नायक के लिए "प्लेयर" टैग

बनाते हैं । अब MonsterBehaviour स्क्रिप्ट बनाएं:



यह MobBehaviour स्क्रिप्ट का एक एनालॉग है। लेकिन इस स्क्रिप्ट के साथ एक भीड़ खिलाड़ी के बाद भी चल सकती है, अगर वह काफी करीब हो। सामान्य तौर पर, भीड़ की आवाजाही के तरीके मोटर में होने चाहिए (हमने पहले से ही इस पर चर्चा की है), लेकिन उदाहरण के लिए लिट्टी और अपने दिमाग को न फटकने के लिए, हम इसे मॉन्स्टरहेवियर में ही करेंगे। कृपया ध्यान दें कि SetDamage (फ्लोट क्षति) विधि को MobHp में लागू नहीं किया गया है। इसमें IsLive = false जोड़ा गया; और Debud.Log () में पाठ बदल गया है। बेशक, आप कुछ और कोड जोड़ सकते हैं। मैं इस तथ्य पर आपका ध्यान आकर्षित करना चाहता हूं कि FindGameObjectWithTag ("प्लेयर") विधि "प्लेयर" टैग के साथ केवल पहला गेमऑबजेक्ट लौटाती है। लेकिन हमारे साथ, और इसलिए वह अकेला है। अगर हमें सभी ऑब्जेक्ट्स प्राप्त करने की आवश्यकता है, तो हमें FindGameObjectsWithTag विधि की आवश्यकता होगी।

 FindGameObjectWithTag("Tag") //  gameObject FindGameObjectsWithTag("Tag")//   gameObject[]    .    . 

ध्यान दें कि हमने खिलाड़ी के ट्रांसफ़ॉर्मेशन को कैश किया, न कि पूरे गेमऑबजेक्ट को। हम विशेष रूप से ट्रांसफ़ॉर्म का उल्लेख करेंगे, और गेम ऑबजेक्ट के माध्यम से यह इस तरह दिखेगा: player.transform जो player.getComponent () के बराबर है। और हर बार ऐसा क्यों करें, जब आप एक बार और तुरंत कैश कर सकते हैं। बेशक, दर्जनों अतिरिक्त getComponent के एक जोड़े से बहुत कुछ नहीं बदलेगा। लेकिन अगर परियोजना बहुत बड़ी है। और प्रत्येक प्रोग्रामर को मिलेगा जहां getComponent और GameObject.Find (...) और GameObject.FindGameObjectWithTag (...) हिट, आदि। यह एक साथ कार्यक्रम को धीमा कर सकता है। कम एफपीएस। क्या आपको इसकी आवश्यकता है?

हम अपनी नई भीड़ (न्यू बॉल) पर MonsterBehaviour और MonsterHp स्क्रिप्ट लटकाएंगे। मुझे निम्नलिखित दृश्य मिला:

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

हम खेल शुरू करते हैं। हम नई भीड़ के करीब पहुंचते हैं। वह हमारी दिशा में आगे बढ़ना शुरू कर देता है। पीछे भागता है, वह रुक जाता है। हम भीड़ पर गोली मारते हैं, यह रंग बदलता है। हम फिर से शूट करते हैं, वह शरमाता है और हमारे बाद नहीं चलता है। 5 सेकंड के बाद यह गायब हो जाता है। आप पुरानी भीड़ में शूटिंग कर सकते हैं और सुनिश्चित कर सकते हैं कि वह अभी भी क्षति प्राप्त करने और मरने में सक्षम है।

तो, POLYMORPHISM की सुंदरता क्या है। हमने एक भीड़ को जोड़ा और उसे एक पटकथा लिखी। लेकिन हमने खिलाड़ी की स्क्रिप्ट और कारतूस की स्क्रिप्ट में कुछ भी नहीं लिखा था।

फिर से, हमारे टैंक शेल को याद करें। हमारे मामले में हमारी स्क्रिप्ट कैसी दिखेगी? बहुत सरल है।लेकिन पहले हम

दोनों भीड़ के लिए "भीड़" टैग जोड़ देंगे ! अब हम अपने कारतूस से एक टैंक विस्फोटक खोल बनायेंगे। हम छींटे, विस्फोट आदि नहीं करेंगे। यह हमारे पाठ के लिए प्रासंगिक नहीं है। दृश्य से लटका हुआ कारतूस निकालें (यदि पहले से हटाया नहीं गया है)। यह केवल MyPrefab फ़ोल्डर में रहना चाहिए। एक नया BigBulletScript स्क्रिप्ट बनाएँ



यह बुलेटस्क्रिप्ट स्क्रिप्ट का एक एनालॉग है। यह एक टैंक कारतूस स्क्रिप्ट है। किसी चीज़ से टकराने पर, गेम "Mob" टैग के साथ सभी गेम ऑब्जेक्ट्स की एक सरणी प्राप्त करने के लिए GameObject.FindGameObjectsWithTag ("Mob") का उपयोग करता है। जाँचता है कि क्या इस ऑब्जेक्ट में MyBehaviour घटक (या इसके उत्तराधिकारी) है और, यदि हां, तो इस ऑब्जेक्ट की दूरी की जाँच करता है। और अगर यह दूरी अटैकडिस्टस से कम है, तो यह ऑब्जेक्ट MyBehaourour (या इसके किसी भी वारिस) के इंटरफेस (सेडैमेज विधि) के माध्यम से नुकसान के अधीन है।

अब हम बुलेटस्क्रिप्ट की स्क्रिप्ट को कारतूस के प्रीफैब से हटा देंगे, और इसके बजाय, बिगबुलस्क्रिप्ट स्क्रिप्ट को लटका दें।

मंच पर एक दूसरे से ज्यादा दूर न हों। हम खेल शुरू करते हैं। हम गोली मारते हैं ताकि कारतूस मॉब के बीच गिर जाए। चार शॉट और दोनों मॉब तैयार हैं। हमने कारतूस पर स्क्रिप्ट को पूरी तरह से बदल दिया, लेकिन हमने मॉब और खिलाड़ी की स्क्रिप्ट को प्रभावित नहीं किया। BigBullrtScript स्क्रिप्ट उस भीड़ पर निर्भर नहीं करता है, जिसमें वह जाता है। यदि भीड़ एक व्यक्ति द्वारा बनाई जाएगी, और दूसरे द्वारा कारतूस, तो उन्हें सभी को अच्छी तरह से समन्वित कार्य के लिए जानना होगा कि सभी भीड़ (सामान्य रूप से, जो कुछ भी नुकसान प्राप्त कर सकते हैं) किसी को भी ले जा सकती है (हम नहीं जानते कि कौन सा है, कोई भी है ) वर्ग MyBehaviour का वारिस। और यह कि इस वारिस के पास एक सेटडैमेज (फ्लोट क्षति) विधि है। यह बहुत सुविधाजनक है। इस प्रकार, 100500 प्रकार के मॉब को प्रोजेक्ट कोड के बाकी हिस्सों के बारे में सोचे बिना ही riveted किया जा सकता है।

संक्षेप में कहना

इस सरल परियोजना में, हमने दो स्थानों पर बहुरूपता का उपयोग किया।

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

2) कारतूस किसी भी भीड़ पर हमला कर सकता है। यहां तक ​​कि कारतूस के निर्माण के बाद भी। आप एक नया कारतूस बना सकते हैं, और मॉब की स्क्रिप्ट को नहीं बदल सकते।

यहाँ एकता एकता के रचनाकारों से बहुरूपता पाठ का लिंक है unity3d.com/learn/tutorials/modules/intermediate/scripting/polymorphism । मेरी राय में, यह घृणित है और समझ में नहीं आता है। मैं इस तथ्य के बारे में बात नहीं कर रहा हूं कि वह अंग्रेजी में है। आप यहाँ बहुरूपता के बारे में और अधिक पढ़ सकते हैं यहाँ sharp-generation.narod.ru/C_Sharp/methods.html । लेकिन पहले, इस ट्यूटोरियल के अध्याय (जिसमें एक लिंक दिया गया है) के पहले जोड़े को पढ़ें, अन्यथा यह स्पष्ट नहीं होगा।

हम बड़े प्रोजेक्ट बनाने के लिए टीम के दृष्टिकोण पर पुनर्विचार करते हैं।

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

आंकड़े में, अंडाकार का मतलब खुद वस्तुओं से नहीं है, लेकिन लिपियों ने उन पर लटका दिया। उदाहरण के लिए

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

हमारे पास सभी लिपियाँ (कक्षाएं) मोनोबेहौर के उत्तराधिकारी हैं। यही वह है जो एकता हमें निर्देशित करती है।

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

 Public ActionScript action; //     ActionScript Public bool callStartAction=true; // ,     Public bool callOpen =false; Public bool callClose =false; 

आगे, कुछ परिस्थितियों में बटन (ट्रिगर आदि) के कोड में (बटन दबाकर या इच्छित वस्तु के ट्रिगर को दर्ज करना), क्रिया वस्तु का वांछित तरीका कहा जाता है

 If(callStartAction) { action. StartAction(); } If(callOpen) { action. Open(); } If(callClose) { action. Close (); } 

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

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

3) एक समान योजना तैयार करने के बाद, हम इसके कार्यान्वयन के लिए आगे बढ़ते हैं। पहले हम स्क्रिप्ट "माता-पिता" बनाते हैं। बाकी सभी उनसे विरासत में मिलेंगे। उदाहरण के लिए, मोटर की स्क्रिप्ट "जनक" निम्नानुसार बनाई जा सकती है:

रेड एक ऐसे कीवर्ड पर जोर देता है जो इस वर्ग के वारिसों को इन तरीकों को अपने तरीके से फिर से परिभाषित करने की अनुमति देगा। घोषणा इस तरह

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

वह सब है।कोड में कुछ "शब्द" हमारी लिपियों को स्वतंत्र और विनिमेय बनाएंगे। सामान्य तौर पर, सभी लिपियों को एक दूसरे से स्वतंत्र होना चाहिए।

हम अगले लेख में बहुरूपता और अन्य ओओपी आकर्षण का उपयोग करना जारी रखते हैं।