टॉवर रक्षा को एकता में एक खेल बनाना: दुश्मनों की परिदृश्य और लहरें

[ट्यूटोरियल का पहला , दूसरा , तीसरा और चौथा भाग]

• छोटे, मध्यम और बड़े आकार के दुश्मनों के लिए समर्थन।
• दुश्मनों की कई लहरों के साथ खेल परिदृश्य बनाएँ।
• परिसंपत्ति विन्यास और गेमप्ले राज्य का पृथक्करण।
• प्रारंभ, रोकें, जीतें, हारें और खेल को गति दें।
• अंतहीन दोहराए जाने वाले परिदृश्य बनाएं।

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

ट्यूटोरियल एकता 2018.4.6f1 में बनाया गया था।


यह बहुत आरामदायक हो रहा है।

अधिक शत्रु

हर बार एक ही नीला क्यूब बनाना बहुत दिलचस्प नहीं है। अधिक दिलचस्प गेमप्ले परिदृश्यों का समर्थन करने के लिए पहला कदम कई प्रकार के दुश्मनों का समर्थन करना होगा।

शत्रु विन्यास

दुश्मनों को अद्वितीय बनाने के कई तरीके हैं, लेकिन हम जटिल नहीं होंगे: हम उन्हें छोटे, मध्यम और बड़े के रूप में वर्गीकृत करते हैं। उन्हें टैग करने के लिए, एक EnemyType गणन बनाएँ।

 public enum EnemyType { Small, Medium, Large } 

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

 public class EnemyFactory : GameObjectFactory { [System.Serializable] class EnemyConfig { public Enemy prefab = default; [FloatRangeSlider(0.5f, 2f)] public FloatRange scale = new FloatRange(1f); [FloatRangeSlider(0.2f, 5f)] public FloatRange speed = new FloatRange(1f); [FloatRangeSlider(-0.4f, 0.4f)] public FloatRange pathOffset = new FloatRange(0f); } [SerializeField] EnemyConfig small = default, medium = default, large = default; … } 

आइए प्रत्येक शत्रु के लिए स्वास्थ्य अनुकूलन भी करें, क्योंकि यह तार्किक है कि बड़े शत्रु छोटे से अधिक हैं।

  [FloatRangeSlider(10f, 1000f)] public FloatRange health = new FloatRange(100f); 

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

  EnemyConfig GetConfig (EnemyType type) { switch (type) { case EnemyType.Small: return small; case EnemyType.Medium: return medium; case EnemyType.Large: return large; } Debug.Assert(false, "Unsupported enemy type!"); return null; } public Enemy Get (EnemyType type = EnemyType.Medium) { EnemyConfig config = GetConfig(type); Enemy instance = CreateGameObjectInstance(config.prefab); instance.OriginFactory = this; instance.Initialize( config.scale.RandomValueInRange, config.speed.RandomValueInRange, config.pathOffset.RandomValueInRange, config.health.RandomValueInRange ); return instance; } 

Enemy.Initialize लिए आवश्यक पैरामीटर स्वास्थ्य जोड़ें। इसे दुश्मन के आकार द्वारा निर्धारित करने के बजाय स्वास्थ्य को सेट करने के लिए इसका उपयोग करें।

  public void Initialize ( float scale, float speed, float pathOffset, float health ) { … Health = health; } 

हम विभिन्न दुश्मनों के डिजाइन बनाते हैं

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


तीन आकारों के दुश्मन क्यूब्स के लिए फैक्टरी।

सबसे तेज़ तरीका यह है कि गेम को बदलकर गेम में सभी तीन प्रकारों को प्रदर्शित करें। Game.SpawnEnemy ताकि वह बीच के बजाय एक यादृच्छिक प्रकार का दुश्मन प्राप्त कर सके।

  void SpawnEnemy () { GameTile spawnPoint = board.GetSpawnPoint(Random.Range(0, board.SpawnPointCount)); Enemy enemy = enemyFactory.Get((EnemyType)(Random.Range(0, 3))); enemy.SpawnOn(spawnPoint); enemies.Add(enemy); } 

विभिन्न प्रकार के शत्रु।

कई कारखाने

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


गोलाकार शत्रु।

दुश्मनों की लहरें

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

सृष्टि क्रम

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

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

 using UnityEngine; [System.Serializable] public class EnemySpawnSequence { [SerializeField] EnemyFactory factory = default; [SerializeField] EnemyType type = EnemyType.Medium; [SerializeField, Range(1, 100)] int amount = 1; [SerializeField, Range(0.1f, 10f)] float cooldown = 1f; } 

लहरें

एक लहर दुश्मन निर्माण अनुक्रम का एक सरल सरणी है। इसके लिए एक EnemyWave EnemyWave प्रकार बनाएं जो एक मानक अनुक्रम से शुरू होता है।

 using UnityEngine; [CreateAssetMenu] public class EnemyWave : ScriptableObject { [SerializeField] EnemySpawnSequence[] spawnSequences = { new EnemySpawnSequence() }; } 

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


बढ़ते क्यूब्स की एक लहर।

परिदृश्यों

गेमप्ले परिदृश्य तरंगों के अनुक्रम से बनाया गया है। इसके लिए, एकल सरणी तरंगों के साथ GameScenario परिसंपत्ति GameScenario बनाएं और फिर परिदृश्य बनाने के लिए इसका उपयोग करें।

 using UnityEngine; [CreateAssetMenu] public class GameScenario : ScriptableObject { [SerializeField] EnemyWave[] waves = {}; } 

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


एमएससी की दो तरंगों वाला परिदृश्य।

अनुक्रम आंदोलन

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


एक नेस्टेड राज्य प्रकार जो इसके अनुक्रम को संदर्भित करता है।

 public class EnemySpawnSequence { … public class State { EnemySpawnSequence sequence; public State (EnemySpawnSequence sequence) { this.sequence = sequence; } } } 

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

 public class EnemySpawnSequence { … public State Begin () => new State(this); public class State { … } } 

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

  [System.Serializable] public class State { … } 

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

  [System.Serializable] public struct State { … } 

अनुक्रम की स्थिति में केवल दो पहलू होते हैं: उत्पन्न दुश्मनों की संख्या और ठहराव समय की प्रगति। हम Progress विधि को जोड़ते हैं, जो समय डेल्टा द्वारा ठहराव के मूल्य को बढ़ाता है, और फिर कॉन्फ़िगर किए गए मूल्य तक पहुंचने पर इसे रीसेट करता है, जैसा कि Game.Update में पीढ़ी के समय के साथ होता है। हम ऐसा होने पर हर बार दुश्मनों की गिनती में वृद्धि करेंगे। इसके अलावा, ठहराव मूल्य को अधिकतम मूल्य के साथ शुरू करना चाहिए ताकि अनुक्रम शुरुआत में बिना ठहराव के दुश्मनों का निर्माण करे।

  int count; float cooldown; public State (EnemySpawnSequence sequence) { this.sequence = sequence; count = 0; cooldown = sequence.cooldown; } public void Progress () { cooldown += Time.deltaTime; while (cooldown >= sequence.cooldown) { cooldown -= sequence.cooldown; count += 1; } } 

राज्य में केवल आवश्यक डेटा होता है।


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

  public float Progress (float deltaTime) { cooldown += deltaTime; while (cooldown >= sequence.cooldown) { cooldown -= sequence.cooldown; if (count >= sequence.amount) { return cooldown; } count += 1; } return -1f; } 

कहीं भी दुश्मन पैदा करो

दुश्मनों को Game.SpawnEnemy लिए दृश्यों के लिए, हमें Game.SpawnEnemy को किसी अन्य सार्वजनिक स्थैतिक विधि में परिवर्तित Game.SpawnEnemy होगा।

  public static void SpawnEnemy (EnemyFactory factory, EnemyType type) { GameTile spawnPoint = instance.board.GetSpawnPoint( Random.Range(0, instance.board.SpawnPointCount) ); Enemy enemy = factory.Get(type); enemy.SpawnOn(spawnPoint); instance.enemies.Add(enemy); } 

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

  void Update () { } 

हम दुश्मनों की गिनती बढ़ाने के बाद Game.SpawnEnemy में EnemySpawnSequence.State.Progress को कॉल करेंगे।

  public float Progress (float deltaTime) { cooldown += deltaTime; while (cooldown >= sequence.cooldown) { … count += 1; Game.SpawnEnemy(sequence.factory, sequence.type); } return -1f; } 

वेव उन्नति

आइए हम एक अनुक्रम के साथ आगे बढ़ने के लिए एक ही दृष्टिकोण लेते हैं जैसे कि पूरी लहर के साथ चलते हैं। आइए EnemyWave अपना खुद का EnemyWave तरीका दें, जो नेस्टेड State स्ट्रक्चर का एक नया उदाहरण देता है। इस मामले में, राज्य में तरंग अनुक्रम और सक्रिय अनुक्रम की स्थिति होती है, जिसे हम पहले अनुक्रम की शुरुआत के साथ शुरू करते हैं।


एक तरंग अवस्था जिसमें एक क्रम की अवस्था होती है।

 public class EnemyWave : ScriptableObject { [SerializeField] EnemySpawnSequence[] spawnSequences = { new EnemySpawnSequence() }; public State Begin() => new State(this); [System.Serializable] public struct State { EnemyWave wave; int index; EnemySpawnSequence.State sequence; public State (EnemyWave wave) { this.wave = wave; index = 0; Debug.Assert(wave.spawnSequences.Length > 0, "Empty wave!"); sequence = wave.spawnSequences[0].Begin(); } } } 

हम EnemyWave.State मेथड Progress को भी जोड़ते हैं, जिसमें पहले की तरह ही मामूली बदलाव के साथ अप्रोच का उपयोग किया जाता है। हम सक्रिय अनुक्रम के साथ आगे बढ़ना शुरू करते हैं और इस कॉल के परिणाम के साथ समय डेल्टा को प्रतिस्थापित करते हैं। जबकि समय बचा है, हम अगले क्रम पर चले जाते हैं, अगर यह एक्सेस किया जाता है, और इस पर प्रगति करते हैं। यदि कोई अनुक्रम नहीं बचा है, तो हम शेष समय वापस करते हैं; अन्यथा एक नकारात्मक मान लौटाएं।

  public float Progress (float deltaTime) { deltaTime = sequence.Progress(deltaTime); while (deltaTime >= 0f) { if (++index >= wave.spawnSequences.Length) { return deltaTime; } sequence = wave.spawnSequences[index].Begin(); deltaTime = sequence.Progress(deltaTime); } return -1f; } 

स्क्रिप्ट का प्रचार

एक ही प्रसंस्करण GameScenario जोड़ें। इस स्थिति में, राज्य में वेव इंडेक्स और सक्रिय तरंग की स्थिति होती है।

 public class GameScenario : ScriptableObject { [SerializeField] EnemyWave[] waves = {}; public State Begin () => new State(this); [System.Serializable] public struct State { GameScenario scenario; int index; EnemyWave.State wave; public State (GameScenario scenario) { this.scenario = scenario; index = 0; Debug.Assert(scenario.waves.Length > 0, "Empty scenario!"); wave = scenario.waves[0].Begin(); } } } 

चूँकि हम शीर्ष स्तर पर हैं, Progress पद्धति के लिए पैरामीटर की आवश्यकता नहीं होती है और आप Time.deltaTime सीधे उपयोग कर सकते हैं। हमें शेष समय को वापस करने की आवश्यकता नहीं है, लेकिन हमें यह दिखाने की आवश्यकता है कि क्या स्क्रिप्ट पूरी हो गई है। हम अंतिम लहर के अंत के बाद false लौटेंगे और यह दिखाने के लिए true है कि स्क्रिप्ट अभी भी सक्रिय है।

  public bool Progress () { float deltaTime = wave.Progress(Time.deltaTime); while (deltaTime >= 0f) { if (++index >= scenario.waves.Length) { return false; } wave = scenario.waves[index].Begin(); deltaTime = wave.Progress(deltaTime); } return true; } 

स्क्रिप्ट रन

Game स्क्रिप्ट खेलने के लिए, आपको एक स्क्रिप्ट कॉन्फ़िगरेशन फ़ील्ड और इसकी स्थिति की ट्रैकिंग की आवश्यकता होती है। हम केवल स्क्रिप्ट को जागृत में चलाएंगे और उस पर Update चलाएंगे जब तक कि बाकी गेम की स्थिति अपडेट न हो जाए।

  [SerializeField] GameScenario scenario = default; GameScenario.State activeScenario; … void Awake () { board.Initialize(boardSize, tileContentFactory); board.ShowGrid = true; activeScenario = scenario.Begin(); } … void Update () { … activeScenario.Progress(); enemies.GameUpdate(); Physics.SyncTransforms(); board.GameUpdate(); nonEnemies.GameUpdate(); } 

अब कॉन्फ़िगर स्क्रिप्ट को गेम की शुरुआत में लॉन्च किया जाएगा। इस पर पदोन्नति पूरी होने तक की जाएगी, और उसके बाद कुछ नहीं होगा।


दो तरंगों को 10 गुना तेज किया।

गेम शुरू करें और समाप्त करें

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

एक नए खेल की शुरुआत

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

  public void Clear () { for (int i = 0; i < behaviors.Count; i++) { behaviors[i].Recycle(); } behaviors.Clear(); } 

इससे पता चलता है कि सभी व्यवहारों का निपटान किया जा सकता है, लेकिन अभी तक यह नहीं है। इस काम को करने के लिए GameBehavior अमूर्त Recycle विधि जोड़ें।

  public abstract void Recycle (); 

WarEntity वर्ग की Recycle विधि स्पष्ट रूप से इसे ओवरराइड करना चाहिए।

  public override void Recycle () { originFactory.Reclaim(this); } 

Enemy पास अभी तक Recycle विधि नहीं है, इसलिए इसे जोड़ें। उसे बस उसे वापस करने के लिए कारखाने को मजबूर करना पड़ता है। तब हम Recycle कहते हैं जहाँ हम सीधे कारखाने तक पहुंचते हैं।

  public override bool GameUpdate () { if (Health <= 0f) { Recycle(); return false; } progress += Time.deltaTime * progressFactor; while (progress >= 1f) { if (tileTo == null) { Recycle(); return false; } … } … } public override void Recycle () { OriginFactory.Reclaim(this); } 

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

  public void Initialize ( Vector2Int size, GameTileContentFactory contentFactory ) { … for (int i = 0, y = 0; y < size.y; y++) { for (int x = 0; x < size.x; x++, i++) { … } } Clear(); } public void Clear () { foreach (GameTile tile in tiles) { tile.Content = contentFactory.Get(GameTileContentType.Empty); } spawnPoints.Clear(); updatingContent.Clear(); ToggleDestination(tiles[tiles.Length / 2]); ToggleSpawnPoint(tiles[0]); } 

अब हम Game , डंपिंग दुश्मनों, अन्य वस्तुओं और क्षेत्र के लिए BeginNewGame विधि को जोड़ सकते हैं, और फिर एक नई स्क्रिप्ट शुरू कर सकते हैं।

  void BeginNewGame () { enemies.Clear(); nonEnemies.Clear(); board.Clear(); activeScenario = scenario.Begin(); } 

यदि आप स्क्रिप्ट पर जाने से पहले B दबाते हैं तो हम Update में इस विधि को कॉल करेंगे।

  void Update () { … if (Input.GetKeyDown(KeyCode.B)) { BeginNewGame(); } activeScenario.Progress(); … } 

हानि

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

  [SerializeField, Range(0, 100)] int startingPlayerHealth = 10; 

प्रारंभ में, एक खिलाड़ी के पास 10 स्वास्थ्य होते हैं।

जागने या एक नए खेल की शुरुआत के मामले में, हम खिलाड़ी के वर्तमान स्वास्थ्य के लिए प्रारंभिक मूल्य प्रदान करते हैं।

  int playerHealth; … void Awake () { playerHealth = startingPlayerHealth; … } void BeginNewGame () { playerHealth = startingPlayerHealth; … } 

एक सार्वजनिक स्थैतिक EnemyReachedDestination विधि जोड़ें EnemyReachedDestination दुश्मन Game को बता सकें कि वे समापन बिंदु पर पहुंच गए हैं। जब ऐसा होता है, तो खिलाड़ी के स्वास्थ्य को कम करें।

  public static void EnemyReachedDestination () { instance.playerHealth -= 1; } 

इस विधि को Enemy.GameUpdate में कॉल करें। उचित समय पर Enemy.GameUpdate ।

  if (tileTo == null) { Game.EnemyReachedDestination(); Recycle(); return false; } 

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

  if (playerHealth <= 0 && startingPlayerHealth > 0) { Debug.Log("Defeat!"); BeginNewGame(); } activeScenario.Progress(); 

जीत

हार का एक विकल्प जीत है, जो परिदृश्य के अंत में हासिल किया जाता है, अगर खिलाड़ी अभी भी जीवित है। यही है, जब GameScenario.Progess का परिणाम false , हम लॉग में एक जीत संदेश प्रदर्शित करते हैं, एक नया गेम शुरू करते हैं, और तुरंत उस पर आगे बढ़ते हैं।

  if (playerHealth <= 0) { Debug.Log("Defeat!"); BeginNewGame(); } if (!activeScenario.Progress()) { Debug.Log("Victory!"); BeginNewGame(); activeScenario.Progress(); } 

हालांकि, जीत आखिरी ठहराव के बाद आएगी, भले ही मैदान पर अभी भी दुश्मन हों। हमें जीत को स्थगित करने की आवश्यकता है जब तक कि सभी दुश्मन गायब न हो जाएं, जो यह पता लगा सकता है कि क्या दुश्मनों का संग्रह खाली है। हम यह मानते हैं कि इसके पास IsEmpty संपत्ति है।

  if (!activeScenario.Progress() && enemies.IsEmpty) { Debug.Log("Victory!"); BeginNewGame(); activeScenario.Progress(); } 

GameBehaviorCollection में वांछित संपत्ति जोड़ें।

  public bool IsEmpty => behaviors.Count == 0; 

समय पर नियंत्रण

चलो समय प्रबंधन सुविधा को भी लागू करते हैं, यह परीक्षण में मदद करेगा और अक्सर गेमप्ले फ़ंक्शन होता है। आरंभ करने के लिए, Game.Update को एक स्पेसबार के लिए चेक करें, और गेम में पॉज़ को सक्षम / अक्षम करने के लिए इस ईवेंट का उपयोग करें। यह शून्य और एक के बीच Time.timeScale मानों को स्विच करके किया जा सकता है। यह गेम लॉजिक को नहीं बदलेगा, बल्कि सभी ऑब्जेक्ट्स को फ्रीज कर देगा। या आप 0 के बजाय बहुत कम मूल्य का उपयोग कर सकते हैं, उदाहरण के लिए 0.01, अत्यंत धीमी गति बनाने के लिए।

  const float pausedTimeScale = 0f; … void Update () { … if (Input.GetKeyDown(KeyCode.Space)) { Time.timeScale = Time.timeScale > pausedTimeScale ? pausedTimeScale : 1f; } if (Input.GetKeyDown(KeyCode.B)) { BeginNewGame(); } … } 

-, Game , .

  [SerializeField, Range(1f, 10f)] float playSpeed = 1f; 

.

, . .

  if (Input.GetKeyDown(KeyCode.Space)) { Time.timeScale = Time.timeScale > pausedTimeScale ? pausedTimeScale : playSpeed; } else if (Time.timeScale > pausedTimeScale) { Time.timeScale = playSpeed; } 

. , . , , , .

GameScenario , 1. , . , , , , .

  [SerializeField, Range(0, 10)] int cycles = 1; 

.

GameScenario.State .

  int cycle, index; EnemyWave.State wave; public State (GameScenario scenario) { this.scenario = scenario; cycle = 0; index = 0; wave = scenario.waves[0].Begin(); } 

Progress , false , . .

  public bool Progress () { float deltaTime = wave.Progress(Time.deltaTime); while (deltaTime >= 0f) { if (++index >= scenario.waves.Length) { if (++cycle >= scenario.cycles && scenario.cycles > 0) { return false; } index = 0; } wave = scenario.waves[index].Begin(); deltaTime = wave.Progress(deltaTime); } return true; } 

, . , . , . .

GameScenario . . , 0.5 ×1, ×1.5, ×2, ×2.5, .

  [SerializeField, Range(0f, 1f)] float cycleSpeedUp = 0.5f; 

GameScenario.State . 1 . Time.deltaTime .

  float timeScale; EnemyWave.State wave; public State (GameScenario scenario) { this.scenario = scenario; cycle = 0; index = 0; timeScale = 1f; wave = scenario.waves[0].Begin(); } public bool Progress () { float deltaTime = wave.Progress(timeScale * Time.deltaTime); while (deltaTime >= 0f) { if (++index >= scenario.waves.Length) { if (++cycle >= scenario.cycles && scenario.cycles > 0) { return false; } index = 0; timeScale += scenario.cycleSpeedUp; } wave = scenario.waves[index].Begin(); deltaTime = wave.Progress(deltaTime); } return true; } 

; .

? Patreon !



PDF