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

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

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

काम पर लगना

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

दृश्यों फ़ोल्डर से GameScene खोलें।

दुश्मनों की बारी

पिछले ट्यूटोरियल के अंत में, दुश्मन ने सड़क पर चलना सीखा, लेकिन ऐसा लगता है कि उसे पता नहीं है कि कहां देखना है।

IDE में MoveEnemy.cs स्क्रिप्ट खोलें और स्थिति को ठीक करने के लिए निम्न विधि जोड़ें।

private void RotateIntoMoveDirection() { //1 Vector3 newStartPosition = waypoints [currentWaypoint].transform.position; Vector3 newEndPosition = waypoints [currentWaypoint + 1].transform.position; Vector3 newDirection = (newEndPosition - newStartPosition); //2 float x = newDirection.x; float y = newDirection.y; float rotationAngle = Mathf.Atan2 (y, x) * 180 / Mathf.PI; //3 GameObject sprite = gameObject.transform.Find("Sprite").gameObject; sprite.transform.rotation = Quaternion.AngleAxis(rotationAngle, Vector3.forward); } 

RotateIntoMoveDirection दुश्मन को घुमाता है ताकि वह हमेशा आगे RotateIntoMoveDirection । वह इसे निम्नानुसार करता है:

1. बग की वर्तमान दिशा की गणना करता है, वर्तमान बिंदु की स्थिति को अगले बिंदु की स्थिति से घटाता है।
2. रेडियन में कोण का निर्धारण करने के लिए Mathf.Atan2 का उपयोग करता है, जहां newDirection निर्देशित है (शून्य बिंदु दाईं ओर है)। परिणाम को 180 / Mathf.PI गुणा करता है, कोण को डिग्री में परिवर्तित करता है।
3. अंत में, यह स्प्राइट बच्चा प्राप्त करता है और अक्ष को घुमाता है। rotationAngle डिग्री। ध्यान दें कि हम बच्चे को घुमाते हैं, माता-पिता को नहीं, ताकि बाद में हम जो ऊर्जा जोड़ते हैं वह क्षैतिज बनी रहे।

Update() , टिप्पणी को बदलें // TODO: अगले कॉल के // TODO: RotateIntoMoveDirection :

 RotateIntoMoveDirection(); 

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


अब बग को पता है कि वह कहां जा रहा है।

एक और केवल दुश्मन बहुत प्रभावशाली नहीं दिखता है। हमें भीड़ चाहिए! और किसी भी टॉवर रक्षा खेल की तरह, लहरों में भीड़ चलती है!

खिलाड़ी को सूचित करें

इससे पहले कि हम भीड़ को स्थानांतरित करना शुरू करें, हमें खिलाड़ी को आसन्न लड़ाई के बारे में चेतावनी देने की आवश्यकता है। इसके अलावा, यह स्क्रीन के शीर्ष पर वर्तमान लहर संख्या को प्रदर्शित करने के लायक है।

कई GameObjects द्वारा वेव जानकारी आवश्यक है, इसलिए हम इसे GameManagerBehavior घटक के GameManager में जोड़ देंगे ।

IDE में GameManagerBehavior.cs खोलें और निम्नलिखित दो चर जोड़ें:

 public Text waveLabel; public GameObject[] nextWaveLabels; 

waveLabel स्क्रीन के ऊपरी दाएं कोने में तरंग संख्या आउटपुट लेबल के लिए एक लिंक संग्रहीत करता है। nextWaveLabels दो nextWaveLabels संग्रहीत करता है जो एनीमेशन का एक संयोजन बनाता है जिसे हम एक नई लहर की शुरुआत में दिखाएंगे:


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

अब नेक्स्ट वेव लेबल्स के लिए साइज 2 पर सेट करें। अब Element 0 को NextWaveBottomLabel पर सेट करें और तत्व 1 NextWaveTopLabel के लिए वैसा ही है जैसा हमने वेव लेबल के साथ किया था।


यह वही है जो गेम मैनेजर व्यवहार को अब देखना चाहिए

यदि खिलाड़ी हार जाता है, तो उसे अगली लहर के बारे में संदेश नहीं देखना चाहिए। इस स्थिति को संभालने के लिए, GameManagerBehavior.cs पर वापस लौटें और एक अन्य चर जोड़ें:

 public bool gameOver = false; 

gameOver हम उस मूल्य को संग्रहीत करेंगे कि क्या खिलाड़ी हार गया।

यहां हम वर्तमान तरंग के साथ खेल के तत्वों को सिंक्रनाइज़ करने के लिए फिर से संपत्ति का उपयोग करते हैं। GameManagerBehavior के लिए निम्न कोड जोड़ें:

 private int wave; public int Wave { get { return wave; } set { wave = value; if (!gameOver) { for (int i = 0; i < nextWaveLabels.Length; i++) { nextWaveLabels[i].GetComponent<Animator>().SetTrigger("nextWave"); } } waveLabel.text = "WAVE: " + (wave + 1); } } 

एक निजी चर, संपत्ति, और गेटटर बनाना आपके लिए पहले से ही एक परिचित चीज होनी चाहिए। लेकिन सेटर के साथ, फिर से, सब कुछ थोड़ा और दिलचस्प है।

हम wave नया value ।

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

अंत में, हम wave + 1 waveLabel का text सेट करते हैं। क्यों +1 ? साधारण लोग खरोंच से गिनती शुरू नहीं करते हैं (हाँ, यह अजीब है)।

Start() इस संपत्ति का मूल्य निर्धारित करते हैं:

 Wave = 0; 

हम संख्या 0 Wave साथ गिनती शुरू करते हैं।

फ़ाइल सहेजें और एकता में दृश्य चलाएँ। वेव लेबल सही ढंग से 1 दिखाएगा।


एक खिलाड़ी के लिए, यह सब लहर 1 से शुरू होता है।

लहरें: दुश्मनों के ढेर बनाएँ

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

यही है, खेल को दृश्य में दुश्मनों की उपस्थिति को पहचानने में सक्षम होना चाहिए, और टैग यहां खेल की वस्तुओं की पहचान करने का एक अच्छा तरीका है।

शत्रु टैगिंग

Project Browser में Enem prefab का चयन करें। इंस्पेक्टर के शीर्ष पर, टैग ड्रॉप-डाउन सूची पर क्लिक करें और ऐड टैग चुनें।


शत्रु नामक एक टैग बनाएं।


Prefab शत्रु का चयन करें। इंस्पेक्टर में, इसके लिए शत्रु टैग सेट करें ।

दुश्मनों की लहरों को परिभाषित करना

अब हमें दुश्मनों की लहर को स्थापित करने की आवश्यकता है। IDE में SpawnEnemy.cs खोलें और SpawnEnemy से पहले निम्न वर्ग कार्यान्वयन जोड़ें:

 [System.Serializable] public class Wave { public GameObject enemyPrefab; public float spawnInterval = 2; public int maxEnemies = 20; } 

वेव में enemyPrefab होता है - इस लहर में सभी दुश्मनों के उदाहरण बनाने का आधार, spawnInterval - सेकंड और maxEnemies में दुश्मनों में लहर के बीच का समय - इस लहर में बनाए गए दुश्मनों की संख्या।

वर्ग Serializable है , अर्थात् , हम इंस्पेक्टर में इसके मूल्यों को बदल सकते हैं।

निम्नलिखित चर को SpawnEnemy वर्ग में जोड़ें:

 public Wave[] waves; public int timeBetweenWaves = 5; private GameManagerBehavior gameManager; private float lastSpawnTime; private int enemiesSpawned = 0; 

यहां हम दुश्मनों को जगाने के लिए चर निर्धारित करते हैं, जो मार्ग पर बिंदुओं के बीच दुश्मनों को ले जाने के तरीके के समान है।

हम अलग-अलग दुश्मनों की लहरों को तरंगों में सेट करते हैं और दुश्मनों की संख्या और उनके द्वारा बनाए गए दुश्मनों को ट्रैक करने की संख्या को ट्रैक करते हैं।

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

निम्नलिखित कोड के Start() की सामग्री को बदलें।

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

यहां हम lastSpawnTime वर्तमान समय का मान प्रदान करते हैं, lastSpawnTime , दृश्य लोड होने के बाद स्क्रिप्ट शुरू होने का समय। तो फिर हम पहले से ही परिचित GameManagerBehavior प्राप्त करते हैं।

Update() करने के लिए निम्न कोड जोड़ें Update() :

 // 1 int currentWave = gameManager.Wave; if (currentWave < waves.Length) { // 2 float timeInterval = Time.time - lastSpawnTime; float spawnInterval = waves[currentWave].spawnInterval; if (((enemiesSpawned == 0 && timeInterval > timeBetweenWaves) || timeInterval > spawnInterval) && enemiesSpawned < waves[currentWave].maxEnemies) { // 3 lastSpawnTime = Time.time; GameObject newEnemy = (GameObject) Instantiate(waves[currentWave].enemyPrefab); newEnemy.GetComponent<MoveEnemy>().waypoints = waypoints; enemiesSpawned++; } // 4 if (enemiesSpawned == waves[currentWave].maxEnemies && GameObject.FindGameObjectWithTag("Enemy") == null) { gameManager.Wave++; gameManager.Gold = Mathf.RoundToInt(gameManager.Gold * 1.1f); enemiesSpawned = 0; lastSpawnTime = Time.time; } // 5 } else { gameManager.gameOver = true; GameObject gameOverText = GameObject.FindGameObjectWithTag ("GameWon"); gameOverText.GetComponent<Animator>().SetBool("gameOver", true); } 

आइए इसका विश्लेषण चरण दर चरण करें:

1. हमें वर्तमान तरंग का सूचकांक मिलता है और जांचें कि क्या यह अंतिम है।
2. यदि ऐसा है, तो हम पिछले दुश्मन स्पॉन के बाद बीते हुए समय की गणना करते हैं और जांचते हैं कि क्या यह दुश्मन बनाने का समय है। यहां हम दो मामलों को ध्यान में रखते हैं। यदि यह लहर में पहला दुश्मन है, तो हम timeBetweenWaves कि क्या timeBetweenWaves से timeInterval है। अन्यथा, हम spawnInterval कि क्या spawnInterval तरंगों से timeInterval है। किसी भी मामले में, हम जांचते हैं कि हमने इस लहर में सभी दुश्मन नहीं बनाए हैं।
3. यदि आवश्यक हो, तो दुश्मन को स्पॉन करें, दुश्मन का एक उदाहरण बनाते हुए enemyPrefab । इसके अलावा enemiesSpawned के मूल्य में enemiesSpawned ।
4. स्क्रीन पर दुश्मनों की संख्या की जाँच करें। यदि वे वहां नहीं हैं, और लहर में यह आखिरी दुश्मन था, तो हम अगली लहर बनाते हैं। लहर के अंत में, हम खिलाड़ी को शेष सभी स्वर्ण का 10 प्रतिशत देते हैं।
5. आखिरी लहर को हराने के बाद, खेल में जीत का एक एनीमेशन यहां खेला जाता है।

स्पॉन अंतराल सेट करना

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

अभी के लिए, शत्रु Prefab के रूप में सभी चार तत्वों के लिए एक शत्रु वस्तु का चयन करें। निम्न के रूप में स्पॉन अंतराल और अधिकतम शत्रु क्षेत्रों को कॉन्फ़िगर करें:

• तत्व 0 : स्पॉन इंटरवल: 2.5 , अधिकतम शत्रु: 5
• तत्व 1 : स्पॉन इंटरवल: 2 , मैक्स दुश्मन: 10
• तत्व 2 : स्पॉन इंटरवल: 2 , मैक्स दुश्मन: 15
• तत्व 3 : स्पॉन अंतराल: 1 , अधिकतम शत्रु: 5

समाप्त योजना इस तरह दिखनी चाहिए:


बेशक, आप जटिलता बढ़ाने या कम करने के लिए इन मूल्यों के साथ प्रयोग कर सकते हैं।

गेम लॉन्च करें। अहा! बीटल ने आपकी कुकी की यात्रा शुरू कर दी है!

अतिरिक्त कार्य: दुश्मनों के विभिन्न प्रकार जोड़ें

किसी भी टॉवर रक्षा खेल को केवल एक प्रकार के दुश्मन के साथ पूरा नहीं माना जा सकता है। सौभाग्य से, Prefabs फ़ोल्डर में Enemy2 भी है।

इंस्पेक्टर में, Prefabs \ Enemy2 का चयन करें और इसमें MoveEnemy स्क्रिप्ट जोड़ें। गति 3 पर सेट करें और शत्रु टैग सेट करें । अब आप इस त्वरित दुश्मन का उपयोग कर सकते हैं ताकि खिलाड़ी आराम न करे!

प्लेयर लाइफ अपडेट

हालांकि दुश्मनों के गिरोह कुकी पर हमला करते हैं, खिलाड़ी को कोई नुकसान नहीं होता है। लेकिन जल्द ही हम इसे ठीक कर देंगे। खिलाड़ी को नुकसान उठाना पड़ता है अगर वह दुश्मन को चुपके करने की अनुमति देता है।

IDE में GameManagerBehavior.cs खोलें और निम्नलिखित दो चर जोड़ें:

 public Text healthLabel; public GameObject[] healthIndicator; 

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

स्वास्थ्य प्रबंधन

अब GameManagerBehavior में खिलाड़ी के स्वास्थ्य को संग्रहीत करने वाली संपत्ति जोड़ें:

 private int health; public int Health { get { return health; } set { // 1 if (value < health) { Camera.main.GetComponent<CameraShake>().Shake(); } // 2 health = value; healthLabel.text = "HEALTH: " + health; // 3 if (health <= 0 && !gameOver) { gameOver = true; GameObject gameOverText = GameObject.FindGameObjectWithTag("GameOver"); gameOverText.GetComponent<Animator>().SetBool("gameOver", true); } // 4 for (int i = 0; i < healthIndicator.Length; i++) { if (i < Health) { healthIndicator[i].SetActive(true); } else { healthIndicator[i].SetActive(false); } } } } 

इस तरह से हम खिलाड़ी के स्वास्थ्य का प्रबंधन करते हैं। और फिर, कोड का मुख्य भाग सेटर में स्थित है:

1. यदि हम खिलाड़ी के स्वास्थ्य को कम करते हैं, तो हम एक सुंदर झटकों को पैदा करने के लिए CameraShake घटक का उपयोग करते हैं। यह स्क्रिप्ट डाउनलोड करने योग्य प्रोजेक्ट में शामिल है और हम यहां इस पर विचार नहीं करेंगे।
2. हम स्क्रीन के ऊपरी बाएं कोने में निजी चर और स्वास्थ्य लेबल को अपडेट करते हैं।
3. यदि स्वास्थ्य 0 पर गिर गया है और खेल का अंत अभी तक नहीं आया है, तो gameOver को true gameOver और gameOver एनीमेशन शुरू करें।
4. हम कुकीज़ में से एक राक्षस को हटा देते हैं। यदि हम उन्हें बंद कर देते हैं, तो यह भाग आसान लिखा जा सकता है, लेकिन यहाँ हम स्वास्थ्य को फिर से शामिल किए जाने का समर्थन करते हैं।

हम प्रारंभ में Health को Start() :

 Health = 5; 

हम Health को 5 सेट करते हैं जब दृश्य खेलना शुरू होता है।

यह सब करने के बाद, अब हम खिलाड़ी के स्वास्थ्य को अपडेट कर सकते हैं जब बग कुकी में जाता है। फ़ाइल को सहेजें और IDE को MoveEnemy.cs स्क्रिप्ट पर जाएं।

स्वास्थ्य में बदलाव

अपने स्वास्थ्य को बदलने के लिए, Update() में टिप्पणी Update() शब्दों के साथ // TODO: और इसे इस कोड से बदलें:

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

इसलिए हम GameManagerBehavior प्राप्त करते हैं और यूनिट को उसके Health से घटाते हैं।

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

पदानुक्रम में एक GameManager का चयन करें और उसके Health लेबल के लिए HealthLabel चुनें।

पदानुक्रम में कुकी ऑब्जेक्ट का विस्तार करें और उसके पांच बच्चे HealthIndicators को GameManager के स्वास्थ्य संकेतक सरणी में खींचें - स्वास्थ्य संकेतक कुकीज़ खाने वाले छोटे हरे राक्षस होंगे।

दृश्य को चलाएं और तब तक प्रतीक्षा करें जब तक कि कीड़े कुकी तक नहीं पहुंच जाते। हारने तक कुछ न करें।

राक्षस बदला

जगह में राक्षस? हां। क्या दुश्मन हमला करते हैं? हाँ, और वे menacing दिखते हैं! इन जानवरों को जवाब देने का समय आ गया है!

ऐसा करने के लिए, हमें निम्नलिखित की आवश्यकता है:

• स्वास्थ्य की लेन ताकि खिलाड़ी जानता है कि कौन से दुश्मन मजबूत हैं और कौन से कमजोर हैं
• एक राक्षस की सीमा के भीतर दुश्मनों का पता लगाना
• निर्णय लेना - किस दुश्मन पर गोली चलाना है
• गोले का एक गुच्छा

शत्रु स्वास्थ्य पट्टी

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

प्रोजेक्ट ब्राउज़र से Prefabs \ Enemy दृश्य पर खींचें।

तब पदानुक्रम में, एक बच्चे के रूप में इसे जोड़ने के लिए दुश्मन पर Images \ Objects \ HealthBarBackground को खींचें और छोड़ें।

इंस्पेक्टर में, HealthBarBackground (0, 1, -4) की स्थिति निर्धारित करें।

फिर प्रोजेक्ट ब्राउज़र में, Images \ Objects \ HealthBar का चयन करें और सुनिश्चित करें कि इसकी धुरी बाएँ है । फिर इसे पदानुक्रम में शत्रु के बच्चे के रूप में जोड़ें और इसकी स्थिति मान (-0.63, 1, -5) सेट करें । X स्केल के लिए, मान को 125 पर सेट करें।

HealthBar गेम ऑब्जेक्ट में HealthBar नामक एक नया C # स्क्रिप्ट जोड़ें। बाद में हम इसे बदल देंगे ताकि यह स्वास्थ्य पट्टी की लंबाई को बदल दे।

पदानुक्रम में शत्रु वस्तु का चयन करने के बाद, सुनिश्चित करें कि उसकी स्थिति (20, 0, 0) है ।

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


अब Prefabs \ Enemy2 के लिए एक स्वास्थ्य पट्टी जोड़ने के लिए इन सभी चरणों को दोहराएं।

स्वास्थ्य पट्टी की लंबाई बदलें

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

 public float maxHealth = 100; public float currentHealth = 100; private float originalScale; 

अधिकतम स्वास्थ्य में दुश्मन के अधिकतम स्वास्थ्य को संग्रहीत किया जाता है, और currentHealth स्वास्थ्य में - शेष स्वास्थ्य। अंत में, ओरिजिनलस्केल में स्वास्थ्य पट्टी का प्रारंभिक आकार है।

originalScale वस्तु को Start() में सहेजें Start() :

 originalScale = gameObject.transform.localScale.x; 

हम localScale गुण का x मान संग्रहीत करते हैं।

Update() करने के लिए निम्न कोड जोड़कर स्वास्थ्य पट्टी का पैमाना निर्धारित करें Update() :

 Vector3 tmpScale = gameObject.transform.localScale; tmpScale.x = currentHealth / maxHealth * originalScale; gameObject.transform.localScale = tmpScale; 

हम localScale को एक अस्थायी चर में कॉपी कर सकते हैं क्योंकि हम इसका x मान अलग से नहीं बदल सकते। फिर हम बीटल के वर्तमान स्वास्थ्य के आधार पर नए एक्स- स्केल की गणना करते हैं और फिर से localScale चर को एक अस्थायी चर पर असाइन करते हैं।

फ़ाइल सहेजें और एकता में गेम लॉन्च करें। शत्रुओं पर आपको स्वास्थ्य की लकीरें दिखाई देंगी।


जबकि खेल चल रहा है, पदानुक्रम में शत्रु (क्लोन) वस्तुओं में से एक का विस्तार करें और उसके बच्चे HealthBar का चयन करें। इसका वर्तमान स्वास्थ्य मूल्य बदलें और देखें कि इसका स्वास्थ्य बार कैसे बदलता है।

रेंज के भीतर दुश्मनों का पता लगाने

अब हमारे राक्षसों को यह पता लगाना होगा कि किन दुश्मनों को निशाना बनाना है। लेकिन इससे पहले कि आप इस अवसर को महसूस करें, आपको मॉन्स्टर और दुश्मन को तैयार करने की आवश्यकता है।

प्रोजेक्ट ब्राउज़र प्रीफैब्स \ मॉन्स्टर का चयन करें और इंस्पेक्टर में सर्कल कोलाइडर 2 डी घटक जोड़ें।

कोलाइडर के रेडियस पैरामीटर को 2.5 पर सेट करें - यह राक्षसों के हमले की त्रिज्या का संकेत देगा।

ट्रिगेर चेक बॉक्स का चयन करें ताकि वस्तुएं इस क्षेत्र से गुजरने के बजाय उससे टकराएं।

अंत में, इंस्पेक्टर के शीर्ष पर, रेयस्टर को अनदेखा करने के लिए मॉन्स्टर की परत सेट करें । संवाद बॉक्स में, हाँ पर क्लिक करें , बच्चों को बदलें । यदि इग्नोर रायकास्ट का चयन नहीं किया जाता है, तो कोलाइडर माउस क्लिक घटनाओं का जवाब देगा। यह एक समस्या होगी क्योंकि राक्षस ब्लॉक घटनाओं को उनके नीचे ओपन्सपॉट ऑब्जेक्ट्स के लिए नियत करते हैं।


यह सुनिश्चित करने के लिए कि दुश्मन को ट्रिगर क्षेत्र में पता चला है, हमें इसमें एक कोलाइडर और एक कठोर शरीर को जोड़ने की आवश्यकता है, क्योंकि एकता केवल ट्रिगर घटनाओं को भेजती है जब एक कठोर शरीर को किसी एक कोलाइडर से जोड़ा जाता है।

प्रोजेक्ट ब्राउज़र में, Prefabs \ Enemy का चयन करें। Rigidbody 2D घटक जोड़ें और बॉडी टाइप के लिए काइनेमैटिक चुनें । इसका मतलब यह है कि शरीर भौतिकी से प्रभावित नहीं होगा।

1 के त्रिज्या के साथ सर्कल कोलाइडर 2 डी जोड़ें। Prefabs \ Enemy 2 के लिए इन चरणों को दोहराएं।

ट्रिगर कॉन्फ़िगर किए गए हैं, इसलिए राक्षस समझेंगे कि दुश्मन उनकी कार्रवाई के दायरे में हैं।

हमें एक और चीज तैयार करने की आवश्यकता है: एक स्क्रिप्ट जो राक्षसों को बताती है जब दुश्मन को नष्ट कर दिया जाता है ताकि वे आग जारी रखते हुए अपवाद न उठाएं।

EnemyDestructionDelegate नामक एक नई C # स्क्रिप्ट बनाएं और इसे दुश्मन और Enemy2 प्रीफैब्स में जोड़ें ।

आईडीई में EnemyDestructionDelegate.cs खोलें और निम्नलिखित प्रतिनिधि घोषणा को जोड़ें:

 public delegate void EnemyDelegate (GameObject enemy); public EnemyDelegate enemyDelegate; 

यहां हम एक delegate बनाते हैं, जो एक फ़ंक्शन के लिए एक कंटेनर है जिसे एक चर के रूप में पारित किया जा सकता है।

नोट : प्रतिनिधियों का उपयोग तब किया जाता है जब एक गेम ऑब्जेक्ट को अन्य गेम ऑब्जेक्ट्स को सक्रिय रूप से सूचित करना चाहिए। एकता प्रलेखन में प्रतिनिधियों के बारे में अधिक पढ़ें।

निम्नलिखित विधि जोड़ें:

 void OnDestroy() { if (enemyDelegate != null) { enemyDelegate(gameObject); } } 

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

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

हम राक्षसों को मारने का लाइसेंस देते हैं

और अब राक्षस अपनी कार्रवाई के दायरे में दुश्मनों का पता लगा सकते हैं। मॉन्स्टर प्रीफ़ैब में एक नई C # स्क्रिप्ट जोड़ें और इसे शूट करें ।

OpenEnemy.cs को IDE में खोलें और Generics को एक्सेस करने के लिए निर्माण का using निम्नलिखित जोड़ें।

 using System.Collections.Generic; 

रेंज के भीतर सभी दुश्मनों को ट्रैक करने के लिए एक चर जोड़ें:

 public List<GameObject> enemiesInRange; 

दुश्मनों में हम रेंज में सभी दुश्मनों को स्टोर करेंगे।

प्रारंभ Start() में फ़ील्ड को Start() ।

 enemiesInRange = new List<GameObject>(); 

शुरुआत में, कार्रवाई की त्रिज्या में कोई दुश्मन नहीं होते हैं, इसलिए हम एक खाली सूची बनाते हैं।

enemiesInRange की सूची भरें enemiesInRange ! स्क्रिप्ट में निम्न कोड जोड़ें:

 // 1 void OnEnemyDestroy(GameObject enemy) { enemiesInRange.Remove (enemy); } void OnTriggerEnter2D (Collider2D other) { // 2 if (other.gameObject.tag.Equals("Enemy")) { enemiesInRange.Add(other.gameObject); EnemyDestructionDelegate del = other.gameObject.GetComponent<EnemyDestructionDelegate>(); del.enemyDelegate += OnEnemyDestroy; } } // 3 void OnTriggerExit2D (Collider2D other) { if (other.gameObject.tag.Equals("Enemy")) { enemiesInRange.Remove(other.gameObject); EnemyDestructionDelegate del = other.gameObject.GetComponent<EnemyDestructionDelegate>(); del.enemyDelegate -= OnEnemyDestroy; } } 

1. OnEnemyDestroy हम दुश्मनों को दुश्मनों से enemiesInRange । जब एक दुश्मन एक राक्षस के चारों ओर एक ट्रिगर पर कदम OnTriggerEnter2D है, तो OnTriggerEnter2D ।
2. फिर हम दुश्मनों को दुश्मन में enemiesInRange सूची सूची और EnemyDestructionDelegate घटना OnEnemyDestroy जोड़ें। तो हम गारंटी देते हैं कि दुश्मन के विनाश पर OnEnemyDestroy कहा जाएगा। हम राक्षसों को मृत दुश्मनों पर गोला बारूद खर्च करना नहीं चाहते हैं, है ना?
3. OnTriggerExit2D हम दुश्मन को सूची से हटाते हैं और प्रतिनिधि को अपंजीकृत करते हैं। अब हम जानते हैं कि कौन से दुश्मन सीमा में हैं।

फ़ाइल सहेजें और एकता में गेम लॉन्च करें। यह सुनिश्चित करने के लिए कि सब कुछ काम कर रहा है, राक्षस को स्थिति दें, इसे चुनें और enemiesInRange में बदलाव का पालन करें। enemiesInRange सूची में शामिल हों।

लक्ष्य चयन

राक्षस अब जानते हैं कि किस दुश्मन की सीमा है। लेकिन जब वे त्रिज्या के कई दुश्मन होंगे तो वे क्या करेंगे?

बेशक, वे जिगर के सबसे करीब से हमला करेंगे!

MoveEnemy.cs IDE स्क्रिप्ट खोलें और इस राक्षस की गणना करने वाली एक नई विधि जोड़ें:

 public float DistanceToGoal() { float distance = 0; distance += Vector2.Distance( gameObject.transform.position, waypoints [currentWaypoint + 1].transform.position); for (int i = currentWaypoint + 1; i < waypoints.Length - 1; i++) { Vector3 startPosition = waypoints [i].transform.position; Vector3 endPosition = waypoints [i + 1].transform.position; distance += Vector2.Distance(startPosition, endPosition); } return distance; } 

कोड दुश्मन द्वारा यात्रा नहीं की गई पथ लंबाई की गणना करता है। ऐसा करने के लिए, यह Distance का उपयोग करता है, जिसे Vector3 दो उदाहरणों के बीच की दूरी के रूप में गणना की जाती है।

हम इस विधि का उपयोग बाद में यह पता लगाने के लिए करेंगे कि हमला करने के लिए कौन सा लक्ष्य है। हालांकि, जबकि हमारे राक्षस सशस्त्र और असहाय नहीं हैं, इसलिए पहले हम इसे करेंगे।

फ़ाइल सहेजें और अपने गोले सेट करने के लिए एकता पर वापस लौटें।

राक्षसों को गोले देते हैं। खोल के बहुत सारे!

प्रोजेक्ट ब्राउज़र से चित्र / ऑब्जेक्ट / बुलेट 1 दृश्य पर खींचें । Z से -2 पर स्थिति सेट करें - x और y पर स्थितियां महत्वपूर्ण नहीं हैं, क्योंकि हम उन्हें हर बार सेट करते हैं जब हम प्रोग्राम निष्पादन के दौरान प्रोजेक्टाइल का एक नया उदाहरण बनाते हैं।

BulletBehavior नामक एक नई C # स्क्रिप्ट जोड़ें, और फिर IDE में इसके लिए निम्न चर जोड़ें:

 public float speed = 10; public int damage; public GameObject target; public Vector3 startPosition; public Vector3 targetPosition; private float distance; private float startTime; private GameManagerBehavior gameManager; 

speed प्रोजेक्टाइल की speed निर्धारित करती है; नाम से damage स्पष्ट है।

target , startPosition और targetPosition प्रोजेक्टाइल की दिशा निर्धारित करते हैं।

distance और startTime प्रक्षेप्य की वर्तमान स्थिति को ट्रैक करता है। जब वह दुश्मन को मारता है तो gameManager खिलाड़ी को पुरस्कृत करता है।

Start() में इन चरों के मान निर्दिष्ट करें:

 startTime = Time.time; distance = Vector2.Distance (startPosition, targetPosition); GameObject gm = GameObject.Find("GameManager"); gameManager = gm.GetComponent<GameManagerBehavior>(); 

startTimeहम वर्तमान समय का मूल्य निर्धारित करते हैं और प्रारंभ और लक्ष्य स्थितियों के बीच की दूरी की गणना करते हैं। हमेशा की तरह, हम प्राप्त करते हैं GameManagerBehavior।

प्रक्षेप्य की गति को नियंत्रित करने के लिए, Update()निम्न कोड जोड़ें :

 // 1 float timeInterval = Time.time - startTime; gameObject.transform.position = Vector3.Lerp(startPosition, targetPosition, timeInterval * speed / distance); // 2 if (gameObject.transform.position.Equals(targetPosition)) { if (target != null) { // 3 Transform healthBarTransform = target.transform.Find("HealthBar"); HealthBar healthBar = healthBarTransform.gameObject.GetComponent<HealthBar>(); healthBar.currentHealth -= Mathf.Max(damage, 0); // 4 if (healthBar.currentHealth <= 0) { Destroy(target); AudioSource audioSource = target.GetComponent<AudioSource>(); AudioSource.PlayClipAtPoint(audioSource.clip, transform.position); gameManager.Gold += 50; } } Destroy(gameObject); } 

1. हम प्रक्षेप्य की नई स्थिति की गणना करते हैं, Vector3.Lerpशुरुआत और अंत के पदों के बीच प्रक्षेप के लिए उपयोग करते हैं।
2. यदि प्रक्षेप्य पहुंचता है targetPosition, तो हम यह देखने के लिए जांच करते हैं कि क्या यह अभी भी मौजूद है target।
3. हम HealthBarलक्ष्य के घटक को प्राप्त करते हैं और damageप्रक्षेप्य के आकार से इसके स्वास्थ्य को कम करते हैं।
4. यदि दुश्मन का स्वास्थ्य शून्य हो जाता है, तो हम इसे नष्ट कर देते हैं, ध्वनि प्रभाव को पुन: उत्पन्न करते हैं और सटीकता के लिए खिलाड़ी को पुरस्कृत करते हैं।

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

हम बड़े गोले बनाते हैं

क्या यह बहुत अच्छा नहीं होगा यदि राक्षस उच्च स्तरों पर अधिक गोले मारना शुरू कर दे? सौभाग्य से, इसे लागू करना आसान है। प्रोजेक्टाइल प्रीफैब बनाने के लिए पदानुक्रम से प्रोजेक्ट टैब पर Bullet1

गेम ऑब्जेक्ट खींचें । मूल ऑब्जेक्ट को दृश्य से हटा दें - हमें अब इसकी आवश्यकता नहीं होगी। दो बार पूर्वनिर्मित नकल Bullet1 । बुलेट 2 और बुलेट 3 की प्रतियों को नाम दें । बुलेट 2 चुनें । में इंस्पेक्टर , क्षेत्र सेट स्प्राइट घटक स्प्राइट प्रतिपादक मूल्य छवियाँ / वस्तुओं / Bullet2



। तो हम Bullet2 को Bullet1 से थोड़ा अधिक बनाएंगे।

प्रक्रिया दोहराएँ स्प्राइट पूर्वनिर्मित बदलने के लिए Bullet3 पर छवियाँ संबंधित / वस्तुओं / Bullet3 । बुलेट व्यवहार

में आगे हम गोले से होने वाली क्षति की मात्रा को समायोजित करेंगे। प्रोजेक्ट टैब में Prefab Bullet1 का चयन करें । इंस्पेक्टर आप देख गोली व्यवहार (स्क्रिप्ट) है, जो प्रदान कर सकते हैं नुकसान मूल्य 10 के लिए Bullet1 , 15 के लिए Bullet2 और 20 के लिए Bullet3

- या कोई अन्य मान जो आपको पसंद हो।

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

प्रीफैब के गोले - आकार स्तर के साथ बढ़ता है

गोले के स्तर को बदलना

राक्षसों के विभिन्न स्तरों के लिए अलग-अलग गोले असाइन करें, ताकि मजबूत राक्षस तेजी से दुश्मनों को नष्ट कर दें।

IDE में MonsterData.cs खोलें और MonsterLevelनिम्नलिखित चर में जोड़ें :

 public GameObject bullet; public float fireRate; 

इसलिए हम प्रत्येक स्तर के राक्षसों के लिए प्रक्षेप्य के प्रीफैब और आग की आवृत्ति निर्धारित करते हैं। फ़ाइल को सहेजें और राक्षस सेटअप को पूरा करने के लिए एकता पर वापस लौटें।

प्रोजेक्ट ब्राउज़र में मॉन्स्टर प्रीफ़ैब का चयन करें । इंस्पेक्टर का विस्तार स्तर घटक में दानव डेटा (स्क्रिप्ट) । प्रत्येक आइटम की आग दर को 1 पर सेट करें । फिर तत्व 0, 1, और 2 के बुलेट पैरामीटर को Bullet1 , Bullet2 और Bullet3 में सेट करें ।

राक्षस का स्तर निम्नानुसार निर्धारित किया जाना चाहिए:


गोले दुश्मनों को मारते हैं? हाँ! चलो आग खोलो!

खुली आग

OpenEnemy.cs को IDE में खोलें और निम्नलिखित चर जोड़ें:

 private float lastShotTime; private MonsterData monsterData; 

जैसा कि नाम से पता चलता है, ये चर अंतिम राक्षस शॉट के समय को ट्रैक करते हैं, साथ ही संरचना MonsterDataजिसमें राक्षस के गोले के प्रकार, आग की आवृत्ति, और इसी तरह की जानकारी होती है।

इन क्षेत्रों का मान निर्धारित करें Start():

 lastShotTime = Time.time; monsterData = gameObject.GetComponentInChildren<MonsterData>(); 

यहां हम lastShotTimeवर्तमान समय के मूल्य को निर्दिष्ट करते हैं और MonsterDataइस ऑब्जेक्ट के घटक तक पहुंच प्राप्त करते हैं ।

शूटिंग को लागू करने के लिए निम्नलिखित विधि जोड़ें:

 void Shoot(Collider2D target) { GameObject bulletPrefab = monsterData.CurrentLevel.bullet; // 1 Vector3 startPosition = gameObject.transform.position; Vector3 targetPosition = target.transform.position; startPosition.z = bulletPrefab.transform.position.z; targetPosition.z = bulletPrefab.transform.position.z; // 2 GameObject newBullet = (GameObject)Instantiate (bulletPrefab); newBullet.transform.position = startPosition; BulletBehavior bulletComp = newBullet.GetComponent<BulletBehavior>(); bulletComp.target = target.gameObject; bulletComp.startPosition = startPosition; bulletComp.targetPosition = targetPosition; // 3 Animator animator = monsterData.CurrentLevel.visualization.GetComponent<Animator>(); animator.SetTrigger("fireShot"); AudioSource audioSource = gameObject.GetComponent<AudioSource>(); audioSource.PlayOneShot(audioSource.clip); } 

1. हमें बुलेट के शुरुआती और लक्षित स्थान मिलते हैं। Z के बराबर स्थिति z सेट करें bulletPrefab। पहले, हम प्रक्षेप्य की पूर्व स्थिति को z में सेट करते हैं ताकि प्रक्षेप्य शूटिंग राक्षस के नीचे दिखाई दे, लेकिन दुश्मनों से ऊपर।
2. हम bulletPrefabउपयुक्त एक का उपयोग करके एक नए शेल का एक उदाहरण बनाते हैं MonsterLevel। असाइन startPositionऔर targetPositionप्रोजेक्टाइल।
3. हम खेल को और अधिक दिलचस्प बनाते हैं: जब राक्षस गोली मारता है, तो शूटिंग का एनीमेशन शुरू करें और लेजर की आवाज़ बजाएं।

यह सब एक साथ रखना

यह सब कुछ एक साथ करने का समय है। लक्ष्य को परिभाषित करें और राक्षस को देखो।


ShootEnemy.cs स्क्रिप्ट में ,Update() इस कोड को जोड़ें :

 GameObject target = null; // 1 float minimalEnemyDistance = float.MaxValue; foreach (GameObject enemy in enemiesInRange) { float distanceToGoal = enemy.GetComponent<MoveEnemy>().DistanceToGoal(); if (distanceToGoal < minimalEnemyDistance) { target = enemy; minimalEnemyDistance = distanceToGoal; } } // 2 if (target != null) { if (Time.time - lastShotTime > monsterData.CurrentLevel.fireRate) { Shoot(target.GetComponent<Collider2D>()); lastShotTime = Time.time; } // 3 Vector3 direction = gameObject.transform.position - target.transform.position; gameObject.transform.rotation = Quaternion.AngleAxis( Mathf.Atan2 (direction.y, direction.x) * 180 / Mathf.PI, new Vector3 (0, 0, 1)); } 

इस कोड चरण पर विचार करें।

1. राक्षस का उद्देश्य निर्धारित करें। हम अधिकतम संभव दूरी पर शुरू करते हैं minimalEnemyDistance। हम सीमा के भीतर सभी दुश्मनों के चक्र में घूमते हैं और दुश्मन को एक नया निशाना बनाते हैं यदि कुकी से उसकी दूरी वर्तमान सबसे छोटी से कम हो।
2. हम कहते हैं Shootकि अगर बीता हुआ समय राक्षस की फायरिंग आवृत्ति से अधिक है और lastShotTimeवर्तमान समय का मूल्य निर्धारित करता है।
3. हम राक्षस और उसके लक्ष्य के बीच रोटेशन के कोण की गणना करते हैं। हम राक्षस को इस कोण पर घुमाते हैं। अब वह हमेशा लक्ष्य को देखेगा।

फ़ाइल सहेजें और एकता में गेम लॉन्च करें। राक्षस कुकीज़ की सख्त सुरक्षा करना शुरू कर देंगे। हम आखिरकार कर रहे हैं!

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

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

हमने इस ट्यूटोरियल में बहुत अच्छा काम किया और अब हमारे पास एक शानदार खेल है।

इस परियोजना के आगे विकास के लिए कुछ विचार हैं:

• अधिक प्रकार के शत्रु और राक्षस
• दुश्मनों के विभिन्न मार्ग
• विभिन्न खेल स्तर

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

एक टॉवर रक्षा हिट गेम बनाने के दिलचस्प विचार इस साक्षात्कार में पाए जा सकते हैं ।