🚙 👩🏿‍🎨 📥 टॉवर रक्षा एक एकता खेल बनाना

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

आप निम्न कार्य करना सीखेंगे:

दुश्मनों की लहरें पैदा करो
उन्हें मार्ग बिंदुओं का पालन करें
टावरों का निर्माण और उन्नयन करें, और उन्हें यह भी सिखाएं कि दुश्मनों को छोटे पिक्सेल में कैसे तोड़ना है

अंत में, हमें गेम का फ्रेम मिलता है, जिसे आगे विकसित किया जा सकता है!

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

मैं ओएस एक्स के लिए एकता में काम करूंगा, लेकिन यह ट्यूटोरियल विंडोज के लिए भी उपयुक्त है।

हाथी दांत टॉवर की खिड़कियों के माध्यम से

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

खिलाड़ी को कुकी को पाने तक सभी कीड़े मारना चाहिए। दुश्मनों की प्रत्येक नई लहर को हराना कठिन होता जा रहा है। जब आप सभी लहरों (जीत!) से बच जाते हैं या कुकीज़ (हानि!) पर पाँच दुश्मन रेंगते हैं, तो खेल समाप्त हो जाता है।

यहाँ समाप्त खेल का एक स्क्रीनशॉट है:

राक्षस, एकजुट! कुकी को सुरक्षित रखें!

काम पर लगना

इस प्रोजेक्ट को खाली डाउनलोड करें, इसे अनज़िप करें और यूनिटी में टॉवरडिफ़ेंस-पार्ट 1-स्टार्टर प्रोजेक्ट खोलें।

ड्राफ्ट प्रोजेक्ट में ग्राफिक्स और साउंड, रेडी-मेड एनिमेशन और कई उपयोगी स्क्रिप्ट हैं। स्क्रिप्ट सीधे टॉवर रक्षा खेलों से संबंधित नहीं हैं, इसलिए मैं यहां उनके बारे में बात नहीं करूंगा। हालाँकि, यदि आप एकता में 2D एनिमेशन बनाने के बारे में अधिक जानना चाहते हैं, तो इस एकता 2D ट्यूटोरियल की जाँच करें।

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

दृश्यों के फ़ोल्डर में स्थित GameScene खोलें और गेम मोड को 4: 3 के पहलू अनुपात पर सेट करें ताकि सभी लेबल पृष्ठभूमि से सही तरीके से मेल खाएं। गेम मोड में, आप निम्नलिखित देखेंगे:

ग्रन्थकारिता:

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

।

जगह को एक क्रॉस के साथ चिह्नित किया गया है: राक्षसों का स्थान

राक्षस केवल एक एक्स के साथ चिह्नित बिंदुओं पर रखा जा सकता है।

उन्हें दृश्य में जोड़ने के लिए, प्रोजेक्ट ब्राउजर से इमेजेस \ ऑब्जेक्ट्स ओपन्सपॉट को दृश्य विंडो में खींचें। जबकि हमारे लिए स्थिति महत्वपूर्ण नहीं है।

एक बार जब आप पदानुक्रम में Openspot का चयन कर लेते हैं, तो इंस्पेक्टर में Add Component पर क्लिक करें और Box Collider 2D का चयन करें। दृश्य विंडो में, एकता एक आयताकार कोलाइडर को हरी रेखा के साथ प्रदर्शित करेगी। हम इस स्थान पर माउस क्लिक को पहचानने के लिए इस कोलाइडर का उपयोग करेंगे।

उसी तरह से Openspot में Audio \ Audio स्रोत घटक जोड़ें। ऑडियो स्रोत घटक के AudioClip पैरामीटर के लिए, ऑडियो फ़ोल्डर में स्थित टॉवर_प्ले फ़ाइल का चयन करें और Play On Awake को अक्षम करें।

हमें 11 और बिंदु बनाने होंगे। हालाँकि इन सभी चरणों को दोहराने का एक प्रलोभन है, एकता के पास एक बेहतर उपाय है: प्रीफैब !

प्रोजेक्ट ब्राउज़र के अंदर पदानुक्रम फ़ोल्डर से Prefabs फ़ोल्डर में Openspot खींचें। इसका नाम पदानुक्रम में नीला हो जाएगा, जिसका अर्थ है कि यह प्रीफ़ैब से जुड़ा हुआ है। कुछ इस तरह:

अब जब हमारे पास प्रीफैब रिक्त है, हम जितनी चाहें उतने प्रतियां बना सकते हैं। प्रोजेक्ट ब्राउज़र के अंदर Prefabs फ़ोल्डर से Openspot को केवल दृश्य विंडो में खींचें और छोड़ें। इसे 11 बार दोहराएं और दृश्य में 12 ऑप्सनपॉट ऑब्जेक्ट दिखाई देंगे।

अब निम्नलिखित निर्देशांक के साथ इन 12 Openspot ऑब्जेक्ट्स को सेट करने के लिए इंस्पेक्टर का उपयोग करें:

(X: -5.2, Y: 3.5, Z: 0)
(X: -2.2, Y: 3.5, Z: 0)
(एक्स: 0.8, वाई: 3.5, जेड: 0)
(X: 3.8, Y: 3.5, Z: 0)
(X: -3.8, Y: 0.4, Z: 0)
(एक्स: -0.8, वाई: 0.4, जेड: 0)
(X: 2.2, Y: 0.4, Z: 0)
(X: 5.2, Y: 0.4, Z: 0)
(X: -5.2, Y: -3.0, Z: 0)
(X: -2.2, Y: -3.0, Z: 0)
(एक्स: 0.8, वाई: -3.0, जेड: 0)
(X: 3.8, Y: -3.0, Z: 0)

जब आप ऐसा करते हैं, तो दृश्य इस तरह दिखाई देगा:

हम राक्षसों को रखते हैं

प्लेसमेंट को सरल बनाने के लिए, प्रोजेक्ट के प्रीफ़ैब फ़ोल्डर में एक मॉन्स्टर प्रीफ़ैब है।

राक्षस Prefab उपयोग करने के लिए तैयार है

फिलहाल, इसमें तीन अलग-अलग स्प्राइट्स और बच्चों के रूप में शूटिंग एनिमेशन के साथ एक खाली गेम ऑब्जेक्ट शामिल है।

प्रत्येक स्प्राइट एक राक्षस है जिसमें विभिन्न स्तरों की शक्ति होती है। प्रीफ़ैब में ऑडियो स्रोत घटक भी शामिल है, जो एक राक्षस द्वारा लेजर फायर करने पर ध्वनि चलाने के लिए लॉन्च किया जाएगा।

अब हम एक स्क्रिप्ट बनाएंगे जो मॉन्सटर को ओपन्सपॉट पर होस्ट करेगी ।

प्रोजेक्ट ब्राउज़र में, Prefabs फ़ोल्डर में Openspot ऑब्जेक्ट का चयन करें। इंस्पेक्टर में, एड कंपोनेंट पर क्लिक करें, और फिर नई स्क्रिप्ट का चयन करें और स्क्रिप्ट का नाम रखें । C Sharp को भाषा के रूप में चुनें और Create and Add पर क्लिक करें। चूंकि हमने स्क्रिप्ट को Openspot के प्रीफ़ैब में जोड़ा है, इसलिए दृश्य में सभी Openspot ऑब्जेक्ट में अब यह स्क्रिप्ट होगी। बहुत बढ़िया!

आईडीई में इसे खोलने के लिए स्क्रिप्ट पर डबल-क्लिक करें। फिर दो चर जोड़ें:

public GameObject monsterPrefab; private GameObject monster;

हम राक्षस बनाने के लिए monsterPrefab में संग्रहीत वस्तु का एक उदाहरण बनाएंगे, और इसे monster में संग्रहीत करेंगे ताकि इसे खेल के दौरान हेरफेर किया जा सके।

प्रति बिंदु एक राक्षस

ताकि केवल एक राक्षस को एक बिंदु पर रखा जा सके, निम्नलिखित विधि जोड़ें:

 private bool CanPlaceMonster() { return monster == null; }

CanPlaceMonster() हम जांच सकते हैं कि monster चर अभी भी null । यदि ऐसा है, तो बिंदु पर कोई राक्षस नहीं है, और हम इसे रख सकते हैं।

जब खिलाड़ी इस GameObject पर क्लिक करता है, तो राक्षस को रखने के लिए अब निम्न कोड जोड़ें:

 //1 void OnMouseUp() { //2 if (CanPlaceMonster()) { //3 monster = (GameObject) Instantiate(monsterPrefab, transform.position, Quaternion.identity); //4 AudioSource audioSource = gameObject.GetComponent<AudioSource>(); audioSource.PlayOneShot(audioSource.clip); // TODO:   } }

जब आप माउस को क्लिक करते हैं या स्क्रीन को छूते हैं तो यह कोड राक्षस को ढूंढता है। वह कैसे काम करता है?

जब कोई खिलाड़ी फिजिकल कोलाइडर GameObject को टच करता है, तो एकता स्वचालित रूप से OnMouseUp कहती है।
जब कहा जाता है, यह विधि एक राक्षस डालता है यदि CanPlaceMonster() true ।
हम Instantiate विधि का उपयोग करके एक राक्षस बनाते हैं, जो निर्दिष्ट स्थिति और रोटेशन के साथ दिए गए प्रीफैब का एक उदाहरण बनाता है। इस स्थिति में, हम monsterPrefab नकल monsterPrefab , इसे वर्तमान गेम ऑबजेक्ट स्थिति और कोई रोटेशन नहीं देते हैं, परिणाम को GameObject ट्रांसफर करते हैं और इसे monster सहेजते हैं।
अंत में, हम PlayOneShot को ऑब्जेक्ट के AudioSource घटक से जुड़े ध्वनि प्रभाव को चलाने के लिए कहते हैं।

अब हमारी PlaceMonster स्क्रिप्ट में एक नया मॉन्स्टर हो सकता है, लेकिन हमें अभी भी एक PlaceMonster निर्दिष्ट करना होगा।

राइट प्रीफैब का उपयोग करना

फ़ाइल सहेजें और एकता पर लौटें।

मॉन्स्टरप्रैब चर को सेट करने के लिए, पहले प्रोजेक्ट के ब्राउज़र में प्रीफ़ैब्स फ़ोल्डर से ओपन्सपॉट ऑब्जेक्ट चुनें।

इंस्पेक्टर में, PlaceMonster (Script) घटक के मॉन्स्टर प्रीफ़ैब फ़ील्ड के दाईं ओर के घेरे पर क्लिक करें और प्रकट होने वाले संवाद बॉक्स में मॉन्स्टर का चयन करें।

वह सब है। दृश्य को लॉन्च करें और माउस को क्लिक करके या स्क्रीन को छूकर विभिन्न स्थानों में राक्षस बनाएं।

बहुत बढ़िया! अब हम राक्षस पैदा कर सकते हैं। हालांकि, वे एक अजीब गंदगी की तरह दिखते हैं, क्योंकि राक्षस के सभी बच्चे स्प्राइट खींचे जाते हैं। अब हम इसे ठीक कर देंगे।

राक्षसों के स्तर को बढ़ाएं

नीचे दिए गए आंकड़े से पता चलता है कि स्तर में वृद्धि के साथ, राक्षस अधिक से अधिक भयावह दिखते हैं।

क्या प्यारी! लेकिन अगर आप उसकी कुकीज़ चुराने की कोशिश करते हैं, तो यह राक्षस एक हत्यारे में बदल जाएगा।

स्क्रिप्ट का उपयोग राक्षस स्तरों की प्रणाली के कार्यान्वयन के लिए आधार के रूप में किया जाता है। यह प्रत्येक स्तर पर राक्षस की शक्ति को ट्रैक करता है और निश्चित रूप से, राक्षस का वर्तमान स्तर।

इस लिपि को जोड़ें।

प्रोजेक्ट ब्राउजर में प्रीफैब / मॉन्स्टर प्रीफैब का चयन करें। एक नया C # स्क्रिप्ट जोड़ें, जिसे MonsterData कहा जाता है। IDE में स्क्रिप्ट खोलें और नीचे दिए गए कोड को MonsterData वर्ग के साथ जोड़ें।

 [System.Serializable] public class MonsterLevel { public int cost; public GameObject visualization; }

इसलिए हम MonsterLevel बनाते हैं। यह मूल्य (सोने में, जिसे हम नीचे समर्थन करेंगे) और राक्षस के स्तर का एक दृश्य प्रतिनिधित्व करते हैं।

हम [System.Serializable] शीर्ष पर जोड़ते हैं ताकि निरीक्षक में वर्ग उदाहरणों को संशोधित किया जा सके। यह हमें स्तर वर्ग के सभी मूल्यों को जल्दी से बदलने की अनुमति देता है, भले ही खेल चल रहा हो। यह खेल को संतुलित करने के लिए अविश्वसनीय रूप से उपयोगी है।

राक्षस स्तर की स्थापना

हमारे मामले में, हम निर्दिष्ट MonsterLevel को List<T> में संग्रहीत करेंगे।

क्यों नहीं सिर्फ MonsterLevel[] उपयोग MonsterLevel[] ? हमें कई बार एक विशिष्ट MonsterLevel ऑब्जेक्ट के सूचकांक की आवश्यकता होगी। हालाँकि इसके लिए कोड लिखना आसान है, फिर भी हमें IndexOf() का उपयोग करना होगा, जो Lists कार्यक्षमता को लागू करता है। यह पहिया को सुदृढ़ करने के लिए कोई मतलब नहीं है।

बाइक को रीइनवेंट करना आमतौर पर एक बुरा विचार है।

MonsterData.cs के शीर्ष पर , निर्माण using निम्नलिखित जोड़ें:

 using System.Collections.Generic;

यह हमें सामान्यीकृत डेटा संरचनाओं तक पहुंच प्रदान करता है ताकि हम स्क्रिप्ट में List<T> वर्ग का उपयोग कर सकें।

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

अब MonsterLevel सूची रखने के लिए MonsterData में निम्नलिखित चर जोड़ें:

 public List<MonsterLevel> levels;

सामान्यीकरणों के लिए धन्यवाद, हम गारंटी दे सकते हैं कि level से List केवल MonsterLevel ऑब्जेक्ट होंगे।

फ़ाइल को सहेजें और प्रत्येक स्तर को कॉन्फ़िगर करने के लिए एकता पर स्विच करें।

प्रोजेक्ट ब्राउज़र में Prefabs / Monster का चयन करें। इंस्पेक्टर अब मोंस्टरडेटा (स्क्रिप्ट) घटक के स्तर क्षेत्र को प्रदर्शित करता है। आकार 3 पर सेट करें।

अगला, प्रत्येक स्तर के लिए लागत निर्धारित करें:

तत्व ० : २००
तत्व १ : ११०
तत्व २ : १२०

अब हम विज़ुअल डिस्प्ले फ़ील्ड के मान निर्दिष्ट करते हैं।

अपने बच्चों को देखने के लिए प्रोजेक्ट ब्राउज़र में Prefabs / Monster का विस्तार करें। बच्चे Monster0 को विज़ुअलाइज़ेशन तत्व 0 फ़ील्ड में खींचें।

इसके बाद, Element 1 को Monster1 , और Element 2 से Monster2 पर सेट करें । GIF इस प्रक्रिया को दिखाता है:

जब आप Prefabs / Monster का चयन करते हैं, तो प्रीफ़ैब को इस तरह दिखना चाहिए:

वर्तमान स्तर सेट करें

IDE में MonsterData.cs पर वापस जाएं और MonsterData में एक और चर जोड़ें।

 private MonsterLevel currentLevel;

निजी चर currentLevel हम राक्षस के वर्तमान स्तर को संग्रहीत करेंगे।

अब currentLevel सेट करें और इसे अन्य स्क्रिप्ट्स के लिए दृश्यमान बनाएं। MonsterData के साथ निम्नलिखित लाइनों को उदाहरण चर की घोषणा के साथ जोड़ें:

 //1 public MonsterLevel CurrentLevel { //2 get { return currentLevel; } //3 set { currentLevel = value; int currentLevelIndex = levels.IndexOf(currentLevel); GameObject levelVisualization = levels[currentLevelIndex].visualization; for (int i = 0; i < levels.Count; i++) { if (levelVisualization != null) { if (i == currentLevelIndex) { levels[i].visualization.SetActive(true); } else { levels[i].visualization.SetActive(false); } } } } }

C # कोड का बहुत बड़ा हिस्सा, सही? आइए इसे क्रम में लें:

निजी चर currentLevel की संपत्ति सेट करें। संपत्ति सेट करके, हम इसे किसी भी अन्य चर की तरह कह सकते हैं: या तो CurrentLevel (क्लास के अंदर) या monster.CurrentLevel रूप में। CurrentLevel (बाहर)। हम किसी संपत्ति के गेट्टर या सेटर विधि में किसी भी व्यवहार को परिभाषित कर सकते हैं, और केवल एक गेट्टर, सेटर या दोनों का निर्माण करके, हम संपत्ति के गुणों को नियंत्रित कर सकते हैं: केवल पढ़ने के लिए, केवल-लिखने और लिखने / पढ़ने के लिए।
गेट्टर में, हम currentLevel का मान लौटाते हैं।
सेटर में, हम currentLevel नया मान प्रदान करते हैं। तब हमें वर्तमान स्तर का सूचकांक मिलता है। अंत में, हम सभी स्तरों के माध्यम से साइकिल currentLevelIndex और currentLevelIndex आधार पर दृश्य प्रदर्शन को सक्षम / अक्षम करते हैं। यह बहुत अच्छा है क्योंकि जब currentLevel बदलता है, तो स्प्राइट स्वचालित रूप से अपडेट हो जाता है। गुण एक बहुत सुविधाजनक चीज हैं!

निम्नलिखित OnEnable कार्यान्वयन जोड़ें:

 void OnEnable() { CurrentLevel = levels[0]; }

यहां हमने CurrentLevel सेट CurrentLevel समय रखा है। यह सुनिश्चित करता है कि केवल वांछित स्प्राइट प्रदर्शित किया जाता है।

नोट : OnEnable में संपत्ति को इनिशियलाइज़ करना महत्वपूर्ण है, और OnStart में नहीं, क्योंकि हम OnEnable तरीकों को कहते हैं।

OnEnable बनने पर (यदि OnEnable को सक्षम स्थिति में सहेजा गया था) OnEnable को तुरंत कॉल किया जाएगा, लेकिन ऑब्जेक्ट के दृश्य के भाग के रूप में चालू होने तक OnStart नहीं बुलाया जाता है।

हमें राक्षस रखने से पहले इस डेटा को सत्यापित करने की आवश्यकता है, इसलिए हम इसे OnEnable आरंभ करते हैं।

फ़ाइल सहेजें और एकता पर लौटें। परियोजना को चलाएं और राक्षसों को रखें; अब वे सबसे निचले स्तर के सही स्प्राइट प्रदर्शित करते हैं।

राक्षस अपग्रेड

IDE पर लौटें और MonsterData में निम्न विधि जोड़ें:

 public MonsterLevel GetNextLevel() { int currentLevelIndex = levels.IndexOf (currentLevel); int maxLevelIndex = levels.Count - 1; if (currentLevelIndex < maxLevelIndex) { return levels[currentLevelIndex+1]; } else { return null; } }

GetNextLevel हमें currentLevel इंडेक्स और उच्चतम स्तर इंडेक्स मिलता है; यदि राक्षस अधिकतम स्तर तक नहीं पहुंचा है, तो अगले स्तर पर वापस आ जाता है। अन्यथा, null वापस आ जाता है।

आप इस विधि का उपयोग यह पता लगाने के लिए कर सकते हैं कि क्या राक्षस अपग्रेड संभव है।

राक्षस के स्तर को बढ़ाने के लिए, निम्नलिखित विधि जोड़ें:

 public void IncreaseLevel() { int currentLevelIndex = levels.IndexOf(currentLevel); if (currentLevelIndex < levels.Count - 1) { CurrentLevel = levels[currentLevelIndex + 1]; } }

यहां हमें वर्तमान स्तर का सूचकांक मिलता है, और फिर यह सुनिश्चित करें कि यह अधिकतम स्तर नहीं है, यह जाँच कर कि यह levels.Count - 1 से कम है levels.Count - 1 । यदि ऐसा है, तो CurrentLevel को अगले स्तर पर CurrentLevel ।

कार्यात्मकता की जाँच करना

फ़ाइल सहेजें और IDE में PlaceMonster.cs पर लौटें । एक नई विधि जोड़ें:

 private bool CanUpgradeMonster() { if (monster != null) { MonsterData monsterData = monster.GetComponent<MonsterData>(); MonsterLevel nextLevel = monsterData.GetNextLevel(); if (nextLevel != null) { return true; } } return false; }

पहले हम जांचते हैं कि क्या एक राक्षस है जिसे null साथ monster चर की तुलना करके सुधार किया जा सकता है। यदि यह सच है, तो हम इसके MonsterData से वर्तमान राक्षस स्तर प्राप्त करते हैं।

फिर हम GetNextLevel() कि अगला स्तर उपलब्ध है या नहीं, क्या GetNextLevel() null नहीं है। यदि एक स्तर की वृद्धि संभव है, तो हम true लौटते true ; अन्यथा false लौटते हैं।

हम सोने के लिए सुधार लागू करते हैं

उन्नयन विकल्प को सक्षम करने के लिए, else if शाखा OnMouseUp else if जोड़ें:

 if (CanPlaceMonster()) { //      } else if (CanUpgradeMonster()) { monster.GetComponent<MonsterData>().IncreaseLevel(); AudioSource audioSource = gameObject.GetComponent<AudioSource>(); audioSource.PlayOneShot(audioSource.clip); // TODO:   }

हम CanUpgradeMonster() का उपयोग करके अपग्रेड की संभावना की जांच करते हैं। यदि संभव हो, तो हम GetComponent() और GetComponent() का उपयोग करके MonsterData घटक का उपयोग करते हैं, जो राक्षस के स्तर को बढ़ाता है। अंत में, हम मॉन्स्टर ऑडियो सोर्स लॉन्च करते हैं।

फ़ाइल सहेजें और एकता पर लौटें। गेम को चलाएं, किसी भी संख्या में राक्षसों को उन्नत करें और अपग्रेड करें (लेकिन अभी के लिए)।

पेइंग गोल्ड - गेम मैनेजर

जबकि हम तुरंत किसी भी राक्षस का निर्माण और सुधार कर सकते हैं, लेकिन क्या यह खेल में दिलचस्प होगा?

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

नीचे दिया गया आंकड़ा उन सभी वस्तुओं को दिखाता है जिन्हें इसमें भाग लेना चाहिए।

सभी चयनित खेल ऑब्जेक्ट को पता होना चाहिए कि खिलाड़ी के पास कितना सोना है।

इस डेटा को संग्रहीत करने के लिए, हम एक सामान्य वस्तु का उपयोग करेंगे जो अन्य वस्तुओं तक पहुंच सकती है।

पदानुक्रम पर राइट-क्लिक करें और Create Empty चुनें। नई GameManager ऑब्जेक्ट का नाम दें ।

GameManagerBehavior नामक एक नई C # स्क्रिप्ट को GameManager में जोड़ें , और फिर इसे IDE में खोलें। हम लेबल में प्लेयर गोल्ड की कुल मात्रा प्रदर्शित करेंगे, इसलिए फ़ाइल के शीर्ष पर निम्न पंक्ति जोड़ें:

 using UnityEngine.UI;

यह हमें Text जैसे यूआई कक्षाओं तक पहुंचने की अनुमति देगा, जिसका उपयोग लेबल के लिए किया जाता है। अब निम्न चर को वर्ग में जोड़ें:

 public Text goldLabel;

यह एक खिलाड़ी के पास सोने की मात्रा प्रदर्शित करने के लिए उपयोग किए जाने वाले Text घटक के लिए एक लिंक संग्रहीत करेगा।

अब जब GameManager को लेबल के बारे में पता है, तो हम चर में संग्रहीत सोने की मात्रा और लेबल में प्रदर्शित मूल्य को कैसे सिंक्रनाइज़ करते हैं? हम एक संपत्ति बनाएंगे।

GameManagerBehavior के लिए निम्न कोड जोड़ें:

 private int gold; public int Gold { get { return gold; } set { gold = value; goldLabel.GetComponent<Text>().text = "GOLD: " + gold; } }

क्या वह परिचित लगता है? कोड CurrentLevel समान है, जिसे हम Monster में सेट करते हैं। पहले हम gold की वर्तमान मात्रा को धारण करने के लिए एक निजी चर gold बनाते हैं। तब हम Gold प्रॉपर्टी (अप्रत्याशित रूप से, सही?) सेट करते हैं और गेट्टर और सेटर को लागू करते हैं।

पानेवाला बस gold का मूल्य लौटाता है। सेटर अधिक दिलचस्प है। चर के मूल्य को सेट करने के अलावा, यह goldLabel लिए नए सोने के मूल्य को प्रदर्शित करने के लिए text क्षेत्र भी निर्धारित करता है।

हम कितने उदार होंगे? यदि आप पैसे के लिए खेद महसूस करते हैं तो खिलाड़ी को 1000 स्वर्ण, या उससे कम देने के लिए Start() में निम्न पंक्ति जोड़ें:

 Gold = 1000;

स्क्रिप्ट पर लेबल ऑब्जेक्ट असाइन करना

फ़ाइल सहेजें और एकता पर लौटें। पदानुक्रम में, GameManager का चयन करें। इंस्पेक्टर में, गोल्ड लेबल के दाईं ओर सर्कल पर क्लिक करें। पाठ का चयन करें संवाद बॉक्स में, दृश्य टैब चुनें और गोल्डलैब चुनें।

दृश्य चलाएं और लेबल गोल्ड: 1000 प्रदर्शित करेगा।

खिलाड़ी के "वॉलेट" की जाँच करना

IDE में PlaceMonster.cs स्क्रिप्ट खोलें और निम्न उदाहरण चर जोड़ें:

 private GameManagerBehavior gameManager;

हम दृश्य में GameManagerBehavior ऑब्जेक्ट के GameManagerBehavior घटक का उपयोग करने के लिए gameManager का उपयोग करेंगे। इसे निर्दिष्ट करने के लिए, निम्नलिखित को Start() :

 gameManager = GameObject.Find("GameManager").GetComponent<GameManagerBehavior>();

हम GameObject.Find() फ़ंक्शन का उपयोग करके गेम मैनजर नामक गेमऑबजेक्ट प्राप्त करते हैं, जो उस नाम से मिली पहली गेम ऑब्जेक्ट को लौटाता है। फिर हम इसके घटक GameManagerBehavior प्राप्त GameManagerBehavior और इसे भविष्य के लिए सहेजते हैं।

नोट : आप यूनिटी संपादक में एक फ़ील्ड सेट करके या GameManager लिए एक स्टैटिक विधि जोड़कर ऐसा कर सकते हैं जो कि सिंगलटन का एक उदाहरण देता है जिसमें से हम GameManagerBehavior प्राप्त कर सकते हैं।

हालांकि, ऊपर दिखाए गए कोड के ब्लॉक में एक अंधेरा घोड़ा है: विधि Find , जो एप्लिकेशन निष्पादन के दौरान अधिक धीरे-धीरे काम करता है; लेकिन यह सुविधाजनक है और इसे मॉडरेशन में उपयोग किया जा सकता है।

मेरे पैसे ले लो!

हमने अभी तक सोने को घटाया नहीं है, इसलिए हम इस लाइन को दो बार OnMouseUp() , प्रत्येक टिप्पणी की जगह // TODO: :

 gameManager.Gold -= monster.GetComponent<MonsterData>().CurrentLevel.cost;

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

अनंत श्रेय? बहुत बढ़िया! लेकिन हम इसकी अनुमति नहीं दे सकते। खिलाड़ी को पर्याप्त स्वर्ण होने पर राक्षसों को दांव पर लगाने में सक्षम होना चाहिए।

राक्षसों के लिए सोने की जाँच

IDE में PlaceMonster.cs पर स्विच करें और निम्नलिखित के CanPlaceMonster() की सामग्री को प्रतिस्थापित करें:

 int cost = monsterPrefab.GetComponent<MonsterData>().levels[0].cost; return monster == null && gameManager.Gold >= cost;

हमें इसके MonsterData में levels से राक्षस प्लेसमेंट की कीमत MonsterData । फिर हम gameManager.Gold कि monster null नहीं है, और वह gameManager.Gold । इस कीमत से कई gameManager.Gold अधिक है।

आपके लिए कार्य: स्वतंत्र रूप से CanUpgradeMonster() जाँच करें कि खिलाड़ी के पास पर्याप्त सोना है या नहीं।

अंदर समाधान

लाइन बदलें:

 return true;

इस पर:

 return gameManager.Gold >= nextLevel.cost;

यह जांच करेगा कि खिलाड़ी के पास अपग्रेड मूल्य से अधिक गोल्ड है या नहीं।

एकता में दृश्य को बचाएं और चलाएं। अब उन लोगों को कैसे राक्षसों को असीमित रूप से जोड़ने की कोशिश करें!

अब हम केवल सीमित संख्या में राक्षसों का निर्माण कर सकते हैं।

टॉवर नीति: दुश्मन, लहरें और रास्ता

यह हमारे दुश्मनों को "मार्ग प्रशस्त" करने का समय है। मार्ग के पहले बिंदु पर दुश्मन दिखाई देते हैं, अगले पर जाते हैं और प्रक्रिया को दोहराते हैं जब तक कि वे कुकी तक नहीं पहुंचते।

आप दुश्मनों को इस तरह आगे बढ़ा सकते हैं:

दुश्मन का पालन करेंगे कि सड़क सेट करें
दुश्मन को सड़क के किनारे ले जाएं
दुश्मन को मोड़ो ताकि वह आगे दिखे

Waypoint से एक सड़क बनाना

पदानुक्रम पर राइट-क्लिक करें और एक नया खाली गेम ऑब्जेक्ट बनाने के लिए Empty चुनें। इसे सड़क का नाम दें और इसे (0, 0, 0) पर रखें ।

अब Hierarchy में रोड पर राइट क्लिक करें और रोड के बच्चे के रूप में एक और खाली गेम ऑब्जेक्ट बनाएं। इसे Waypoint0 नाम दें और बिंदु (-12, 2, 0) पर रखें - यहां से दुश्मन अपने आंदोलन को शुरू करेंगे।

इसी प्रकार, निम्नलिखित नामों और पदों के साथ पाँच और मार्ग बिंदु बनाएँ:

Waypoint1: (X: 7, Y: 2, Z: 0)
Waypoint2: (X: 7, Y: -1, Z: 0)
Waypoint3: (X: -7.3, Y: -1, Z: 0)
Waypoint4: (X: -7.3, Y: -4.5, Z: 0)
Waypoint5: (X: 7, Y: -4.5, Z: 0)

नीचे दिया गया स्क्रीनशॉट मार्ग के बिंदु और परिणामी मार्ग दिखाता है।

शत्रु बनाना

अब कुछ दुश्मन पैदा करें ताकि वे सड़क के किनारे-किनारे चल सकें। Prefabs फ़ोल्डर में एक शत्रु prefab है। इसकी स्थिति (-20, 0, 0) है , इसलिए नए उदाहरणों को ऑफ-स्क्रीन बनाया जाएगा।

अन्य सभी मामलों में, यह लगभग उसी तरह से कॉन्फ़िगर किया गया है जैसे कि मॉन्स्टर AudioSource में AudioSource और Sprite बच्चा है, और हम इस स्प्राइट को भविष्य में स्वास्थ्य पट्टी को चालू किए बिना घुमा सकते हैं।

हम दुश्मनों को सड़क पर घुमाते हैं

Prefabs \ Enemy prefab में MoveEnemy नामक एक नया C # स्क्रिप्ट जोड़ें। आईडीई में स्क्रिप्ट खोलें और निम्नलिखित चर जोड़ें:

 [HideInInspector] public GameObject[] waypoints; private int currentWaypoint = 0; private float lastWaypointSwitchTime; public float speed = 1.0f;

[HideIn inspector ] , रूट पॉइंट्स की एक कॉपी एरे में संग्रहित की जाती है, और [HideIn inspector ] ऊपर [HideIn inspector ] यह सुनिश्चित करती है कि हम गलती से इस फील्ड को इंस्पेक्टर में नहीं बदल सकते, लेकिन फिर भी अन्य स्क्रिप्ट्स तक इसकी पहुंच होगी।

currentWaypoint पर नज़र रखता है कि मौजूदा समय में दुश्मन का मार्ग कहाँ से है, और lastWaypointSwitchTime उस समय को संग्रहीत करता है जिससे दुश्मन गुजरता है। इसके अलावा, हम दुश्मन की speed संग्रहीत करते हैं।

इस लाइन को Start() जोड़ें:

 lastWaypointSwitchTime = Time.time;

इसलिए हम वर्तमान समय के मूल्य के साथ lastWaypointSwitchTime को इनिशियलाइज़ lastWaypointSwitchTime ।

दुश्मन को मार्ग में ले जाने के लिए, Update() के लिए निम्न कोड जोड़ें Update() :

 // 1 Vector3 startPosition = waypoints [currentWaypoint].transform.position; Vector3 endPosition = waypoints [currentWaypoint + 1].transform.position; // 2 float pathLength = Vector3.Distance (startPosition, endPosition); float totalTimeForPath = pathLength / speed; float currentTimeOnPath = Time.time - lastWaypointSwitchTime; gameObject.transform.position = Vector2.Lerp (startPosition, endPosition, currentTimeOnPath / totalTimeForPath); // 3 if (gameObject.transform.position.Equals(endPosition)) { if (currentWaypoint < waypoints.Length - 2) { // 3.a currentWaypoint++; lastWaypointSwitchTime = Time.time; // TODO:     } else { // 3.b Destroy(gameObject); AudioSource audioSource = gameObject.GetComponent<AudioSource>(); AudioSource.PlayClipAtPoint(audioSource.clip, transform.position); // TODO:   } }

चलो चरण दर चरण विश्लेषण करें:

रूट पॉइंट्स की सरणी से हमें वर्तमान रूट सेगमेंट की शुरुआत और अंत की स्थिति मिलती है।
हम सूत्र समय = दूरी / गति का उपयोग करके पूरी दूरी को कवर करने के लिए आवश्यक समय की गणना करते हैं, और फिर मार्ग पर वर्तमान समय निर्धारित करते हैं। Vector2.Lerp का उपयोग करते Vector2.Lerp , हम शुरू और अंत सटीक खंड के बीच दुश्मन की वर्तमान स्थिति को प्रक्षेपित करते हैं।
जांचें कि क्या दुश्मन endPosition तक पहुंच endPosition । यदि हाँ, तो हम दो संभावित परिदृश्यों की प्रक्रिया करते हैं:
1. दुश्मन अभी तक मार्ग के अंतिम बिंदु तक नहीं पहुंचा है, इसलिए currentWaypoint का मान currentWaypoint और currentWaypoint को अपडेट lastWaypointSwitchTime । बाद में हम दुश्मन को चालू करने के लिए एक कोड जोड़ेंगे ताकि वह अपने आंदोलन की दिशा में दिखे।
2. दुश्मन मार्ग के अंतिम बिंदु पर पहुंच गया है, फिर हम इसे नष्ट कर देते हैं और ध्वनि प्रभाव शुरू करते हैं। बाद में हम एक कोड जोड़ेंगे जो खिलाड़ी के health कम करेगा।

फ़ाइल सहेजें और एकता पर लौटें।

हम दुश्मनों को आंदोलन की दिशा की जानकारी देते हैं

अपनी वर्तमान स्थिति में, दुश्मनों को मार्ग बिंदुओं का क्रम नहीं पता है।

पदानुक्रम में सड़क का चयन करें और एक नई C # स्क्रिप्ट जोड़ें, जिसे SpawnEnemy कहा जाता है। इसे IDE में खोलें और निम्न चर जोड़ें:

 public GameObject[] waypoints;

हम वांछित क्रम में दृश्य में वेनपॉइंट के संदर्भों को संग्रहीत करने के लिए waypoints का उपयोग करेंगे।

फ़ाइल सहेजें और एकता पर लौटें। पदानुक्रम में सड़क का चयन करें और वेपाइन्स सरणी के आकार को 6 पर सेट करें।

तत्व 0 में Waypoint0 , तत्व 1 में Waypoint1 को चिपकाकर, सड़क के प्रत्येक बच्चों को खेतों में खींचें।

अब हमारे पास एक सरणी है जिसमें सही क्रम में मार्ग बिंदु हैं - आप पर ध्यान दें, दुश्मन कभी भी पीछे नहीं हटते हैं, वे लगातार एक मिठाई इनाम के लिए प्रयास करते हैं।

जांचें कि यह सब कैसे काम करता है

IDE में SpawnEnemy खोलें और निम्नलिखित चर जोड़ें:

 public GameObject testEnemyPrefab;

यह शत्रु testEnemyPrefab संदर्भ को testEnemyPrefab में testEnemyPrefab ।

स्क्रिप्ट चलाते समय दुश्मन बनाने के लिए, Start() करने के लिए निम्न कोड जोड़ें Start() :

 Instantiate(testEnemyPrefab).GetComponent<MoveEnemy>().waypoints = waypoints;

इसलिए हम testEnemy में संग्रहीत testEnemy की एक नई प्रति testEnemy और इसे एक मार्ग निर्दिष्ट करेंगे।

फ़ाइल सहेजें और एकता पर लौटें। पदानुक्रम में रोड ऑब्जेक्ट का चयन करें और टेस्ट शत्रु पैरामीटर के लिए शत्रु prefab का चयन करें।

प्रोजेक्ट लॉन्च करें और देखें कि दुश्मन सड़क के साथ कैसे चलता है (स्पष्टता के लिए GIF में, गति 20 गुना बढ़ जाती है)।

ध्यान दिया कि वह हमेशा नहीं देखता कि वह कहाँ जा रहा है? यह मज़ेदार है, लेकिन हम एक पेशेवर खेल बनाने की कोशिश कर रहे हैं। इसलिए, ट्यूटोरियल के दूसरे भाग में हम दुश्मनों को आगे देखना सिखाएंगे।

आगे कहाँ जाना है?

हम पहले ही बहुत कुछ कर चुके हैं और जल्दी से अपना टॉवर रक्षा खेल बनाने की दिशा में आगे बढ़ रहे हैं।

खिलाड़ी सीमित संख्या में राक्षस बना सकते हैं, और दुश्मन सड़क पर चलता है, हमारे कुकी की ओर बढ़ रहा है। खिलाड़ियों के पास सोना है और वे राक्षसों को उन्नत कर सकते हैं।

तैयार परिणाम को यहां से डाउनलोड करें ।

में दूसरे भाग हम दुश्मनों के विशाल लहरों बनाने को देखो और उन्हें नष्ट कर देगा। जल्द मिलते हैं!

टॉवर रक्षा एक एकता खेल बनाना - भाग 1