🤽🏼 ⬆️ 👈 एकता में टॉवर रक्षा बनाना: दुश्मन ✋🏾 👆🏽 🕴🏽

[ पहला भाग: टाइल्स और रास्ता खोजना ]

शत्रु निर्माण बिंदुओं का स्थान।
मैदान में दुश्मनों और उनके आंदोलन की उपस्थिति।
एक स्थिर गति से चिकनी गति बनाना।
दुश्मनों के आकार, गति और स्थान को बदलें।

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

यह ट्यूटोरियल यूनिटी 2018.3.0f2 में बनाया गया है।

अंत बिंदु के रास्ते पर दुश्मन।

शत्रु निर्माण (स्पॉन) अंक

इससे पहले कि हम दुश्मन बनाना शुरू करें, हमें यह तय करने की जरूरत है कि उन्हें मैदान पर कहां रखा जाए। ऐसा करने के लिए, हम स्पॉन पॉइंट बनाएंगे।

टाइल की सामग्री

स्पॉन पॉइंट एक अन्य प्रकार की टाइल सामग्री है, इसलिए इसके लिए GameTileContentType में एक प्रविष्टि जोड़ें।

 public enum GameTileContentType { Empty, Destination, Wall, SpawnPoint }

और फिर इसकी कल्पना करने के लिए एक प्रीफैब बनाएं। शुरुआती बिंदु के प्रीफैब का एक डुप्लिकेट हमारे लिए काफी उपयुक्त है, बस इसके प्रकार की सामग्री को बदलें और इसे एक और सामग्री दें। मैंने इसे नारंगी बना दिया।

स्पॉन पॉइंट कॉन्फ़िगरेशन।

सामग्री फैक्ट्री में स्पॉन पॉइंट सपोर्ट जोड़ें और इसे प्रीफैब का लिंक दें।

  [SerializeField] GameTileContent spawnPointPrefab = default; … public GameTileContent Get (GameTileContentType type) { switch (type) { case GameTileContentType.Destination: return Get(destinationPrefab); case GameTileContentType.Empty: return Get(emptyPrefab); case GameTileContentType.Wall: return Get(wallPrefab); case GameTileContentType.SpawnPoint: return Get(spawnPointPrefab); } Debug.Assert(false, "Unsupported type: " + type); return null; }

स्पॉन पॉइंट के लिए समर्थन के साथ फैक्टरी।

स्पॉन पॉइंट को सक्षम या अक्षम करें

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

  public void ToggleSpawnPoint (GameTile tile) { if (tile.Content.Type == GameTileContentType.SpawnPoint) { tile.Content = contentFactory.Get(GameTileContentType.Empty); } else if (tile.Content.Type == GameTileContentType.Empty) { tile.Content = contentFactory.Get(GameTileContentType.SpawnPoint); } }

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

  List<GameTile> spawnPoints = new List<GameTile>(); … public void ToggleSpawnPoint (GameTile tile) { if (tile.Content.Type == GameTileContentType.SpawnPoint) { if (spawnPoints.Count > 1) { spawnPoints.Remove(tile); tile.Content = contentFactory.Get(GameTileContentType.Empty); } } else if (tile.Content.Type == GameTileContentType.Empty) { tile.Content = contentFactory.Get(GameTileContentType.SpawnPoint); spawnPoints.Add(tile); } }

Initialize विधि को अब क्षेत्र की प्रारंभिक सही स्थिति बनाने के लिए स्पॉन पॉइंट सेट करना चाहिए। चलो बस पहली टाइल शामिल करें, जो निचले बाएं कोने में है।

  public void Initialize ( Vector2Int size, GameTileContentFactory contentFactory ) { … ToggleDestination(tiles[tiles.Length / 2]); ToggleSpawnPoint(tiles[0]); }

हम वैकल्पिक स्पर्श को अब स्पॉन पॉइंट्स की स्थिति में बदल देंगे, लेकिन जब आप बाईं Shift कुंजी रखते हैं ( Input.GetKey द्वारा कीस्ट्रोक की जाँच की जाती है। विधि विधि), अंतिम बिंदु की स्थिति स्विच हो जाएगी

  void HandleAlternativeTouch () { GameTile tile = board.GetTile(TouchRay); if (tile != null) { if (Input.GetKey(KeyCode.LeftShift)) { board.ToggleDestination(tile); } else { board.ToggleSpawnPoint(tile); } } }

स्पॉन डॉट्स के साथ फ़ील्ड।

स्पॉन पॉइंट तक पहुंच प्राप्त करें

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

  public GameTile GetSpawnPoint (int index) { return spawnPoints[index]; }

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

  public int SpawnPointCount => spawnPoints.Count;

शत्रु स्पॉन

एक दुश्मन को पैदा करना कुछ हद तक एक टाइल की सामग्री बनाने के समान है। हम कारखाने के माध्यम से एक प्रीफैब उदाहरण बनाते हैं, जिसे हम फिर मैदान पर रखते हैं।

फ़ैक्टरी

हम दुश्मनों के लिए एक ऐसी फैक्ट्री बनाएंगे जो वह सब कुछ बनाएगी जो वह अपने स्तर पर बनाता है। यह कार्यक्षमता हमारे पास पहले से मौजूद फैक्ट्री के साथ आम है, तो चलिए इसके लिए कोड को आम आधार वर्ग GameObjectFactory । हमें एक सामान्य CreateGameObjectInstance पैरामीटर के साथ केवल एक CreateGameObjectInstance विधि की आवश्यकता होगी, जो एक उदाहरण बनाता है और रिटर्न करता है, और पूरे दृश्य का प्रबंधन भी करता है। हम protected विधि बनाते हैं, protected यह केवल उस वर्ग और सभी प्रकारों के लिए उपलब्ध होगी जो इसे प्राप्त करते हैं। यह सब वर्ग करता है, यह पूरी तरह कार्यात्मक कारखाने के रूप में इस्तेमाल करने का इरादा नहीं है। इसलिए, हम इसे abstract रूप में चिह्नित करते हैं, जो हमें इसकी वस्तुओं के उदाहरणों को बनाने की अनुमति नहीं देगा।

 using UnityEngine; using UnityEngine.SceneManagement; public abstract class GameObjectFactory : ScriptableObject { Scene scene; protected T CreateGameObjectInstance<T> (T prefab) where T : MonoBehaviour { if (!scene.isLoaded) { if (Application.isEditor) { scene = SceneManager.GetSceneByName(name); if (!scene.isLoaded) { scene = SceneManager.CreateScene(name); } } else { scene = SceneManager.CreateScene(name); } } T instance = Instantiate(prefab); SceneManager.MoveGameObjectToScene(instance.gameObject, scene); return instance; } }

GameTileContentFactory बदलें ताकि यह इस प्रकार की फैक्ट्री को GameTileContentFactory और अपने Get CreateGameObjectInstance में CreateGameObjectInstance का उपयोग CreateGameObjectInstance और फिर इसमें से सीन कंट्रोल कोड को हटा दें।

 using UnityEngine; [CreateAssetMenu] public class GameTileContentFactory : GameObjectFactory { … //Scene contentScene; … GameTileContent Get (GameTileContent prefab) { GameTileContent instance = CreateGameObjectInstance(prefab); instance.OriginFactory = this; //MoveToFactoryScene(instance.gameObject); return instance; } //void MoveToFactoryScene (GameObject o) { // … //} }

उसके बाद, एक नया EnemyFactory प्रकार बनाएँ, जो Reclaim Get विधि के साथ-साथ Get विधि का उपयोग करके एक Enemy EnemyFactory एक उदाहरण बनाता है।

 using UnityEngine; [CreateAssetMenu] public class EnemyFactory : GameObjectFactory { [SerializeField] Enemy prefab = default; public Enemy Get () { Enemy instance = CreateGameObjectInstance(prefab); instance.OriginFactory = this; return instance; } public void Reclaim (Enemy enemy) { Debug.Assert(enemy.OriginFactory == this, "Wrong factory reclaimed!"); Destroy(enemy.gameObject); } }

नए Enemy प्रकार को शुरू में केवल अपने मूल कारखाने का ध्यान रखना था।

 using UnityEngine; public class Enemy : MonoBehaviour { EnemyFactory originFactory; public EnemyFactory OriginFactory { get => originFactory; set { Debug.Assert(originFactory == null, "Redefined origin factory!"); originFactory = value; } } }

पूर्वनिर्मित

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

प्रीफैब रूट

आइए इस ऑब्जेक्ट को एकमात्र बाल तत्व बनाते हैं, जो मॉडल का मूल होगा। इसमें ट्रांसफॉर्म यूनिट वैल्यू होनी चाहिए।

मॉडल की जड़।

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

घन मॉडल

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

दुश्मन का पूर्वपद पदानुक्रम।

चलो एक दुश्मन का कारखाना बनाते हैं और इसे एक प्रीफैब असाइन करते हैं।

एसेट फैक्ट्री।

मैदान पर दुश्मनों का सामना करना

दुश्मनों को मैदान पर लाने के लिए, Game को दुश्मनों के कारखाने के लिए एक लिंक प्राप्त करना होगा। चूंकि हमें दुश्मनों की बहुत आवश्यकता है, इसलिए हम प्रति सेकंड दुश्मनों की संख्या में व्यक्त की गई स्पॉनिंग की गति को समायोजित करने के लिए एक कॉन्फ़िगरेशन विकल्प जोड़ेंगे। एक स्वीकार्य सीमा 1 के डिफ़ॉल्ट मान के साथ 0.1-10 है।

  [SerializeField] EnemyFactory enemyFactory = default; [SerializeField, Range(0.1f, 10f)] float spawnSpeed = 1f;

एक दुश्मन कारखाने और 4 गति spawning के साथ खेल।

हम Update में स्पॉनिंग की प्रगति को ट्रैक करेंगे, इसे डेल्टा समय की गति से बढ़ाएंगे। यदि prggress मान 1 से अधिक है, तो हम इसे SpawnEnemy और नए SpawnEnemy विधि का उपयोग करके दुश्मन को स्पॉन करते हैं। हम इसे तब तक जारी रखते हैं जब तक कि प्रगति 1 से अधिक नहीं हो जाती है यदि गति बहुत अधिक है और फ्रेम का समय बहुत लंबा है ताकि एक ही समय में कई दुश्मन पैदा न हों।

  float spawnProgress; … void Update () { … spawnProgress += spawnSpeed * Time.deltaTime; while (spawnProgress >= 1f) { spawnProgress -= 1f; SpawnEnemy(); } }

क्या FixedUpdate में प्रगति को अद्यतन करना आवश्यक नहीं है?

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

बता दें कि SpawnEnemy को मैदान से एक यादृच्छिक स्पॉन पॉइंट मिलता है और इस टाइल में एक दुश्मन बनाते हैं। हम Enemy को सही ढंग से SpawnOn देने के लिए SpawnOn विधि देंगे।

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

अभी के लिए, सभी SpawnOn को टाइल के केंद्र के बराबर अपनी स्थिति निर्धारित करनी होगी। चूंकि प्रीफैब मॉडल को सही ढंग से तैनात किया गया है, इसलिए दुश्मन का क्यूब इस टाइल के ऊपर होगा।

  public void SpawnOn (GameTile tile) { transform.localPosition = tile.transform.localPosition; }

दुश्मन स्पॉन पॉइंट पर दिखाई देते हैं।

हिलते हुए दुश्मन

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

दुश्मनों का संग्रह

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

  public bool GameUpdate () { transform.localPosition += Vector3.forward * Time.deltaTime; return true; }

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

 using System.Collections.Generic; [System.Serializable] public class EnemyCollection { List<Enemy> enemies = new List<Enemy>(); public void Add (Enemy enemy) { enemies.Add(enemy); } public void GameUpdate () { for (int i = 0; i < enemies.Count; i++) { if (!enemies[i].GameUpdate()) { int lastIndex = enemies.Count - 1; enemies[i] = enemies[lastIndex]; enemies.RemoveAt(lastIndex); i -= 1; } } } }

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

  EnemyCollection enemies = new EnemyCollection(); … void Update () { … enemies.GameUpdate(); } … void SpawnEnemy () { … enemies.Add(enemy); }

शत्रु आगे बढ़ रहे हैं।

रास्ते में हलचल

दुश्मन पहले से ही आगे बढ़ रहे हैं, लेकिन अभी तक पथ का अनुसरण नहीं करते हैं। ऐसा करने के लिए, उन्हें यह जानना होगा कि आगे कहाँ जाना है। इसलिए, चलिए GameTile को पथ पर अगली टाइल प्राप्त करने के लिए GameTile सामान्य गेटर प्रॉपर्टी दें।

  public GameTile NextTileOnPath => nextOnPath;

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

Enemy दोनों टाइलों को ट्रैक करने दें, ताकि वह मार्ग में परिवर्तन से प्रभावित न हो। वह पदों को भी ट्रैक करेगा ताकि हमें उन्हें प्रत्येक फ्रेम में प्राप्त न करना पड़े, और चलने की प्रक्रिया को ट्रैक करना पड़े।

  GameTile tileFrom, tileTo; Vector3 positionFrom, positionTo; float progress;

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

  public void SpawnOn (GameTile tile) { //transform.localPosition = tile.transform.localPosition; Debug.Assert(tile.NextTileOnPath != null, "Nowhere to go!", this); tileFrom = tile; tileTo = tile.NextTileOnPath; positionFrom = tileFrom.transform.localPosition; positionTo = tileTo.transform.localPosition; progress = 0f; }

GameUpdate में प्रगति वृद्धि का प्रदर्शन किया जाएगा। आइए एक स्थिर समय डेल्टा जोड़ें, ताकि दुश्मन प्रति सेकंड एक टाइल की गति से आगे बढ़ें। जब प्रगति पूरी हो जाती है, तो हम डेटा को शिफ्ट कर देते हैं ताकि मूल्य From , और नया TO पथ पर अगली टाइल बन जाए। फिर हम प्रगति में कमी करते हैं। जब डेटा प्रासंगिक हो जाता है, तो हम From और के बीच दुश्मन की स्थिति को प्रक्षेपित करते हैं। चूंकि प्रक्षेपक प्रगति है, इसलिए इसका मान आवश्यक रूप से 0 और 1 की सीमा में है, इसलिए हम s Vector3.LerpUnclamped उपयोग कर सकते हैं। Vector3.LerpUnclamped ।

  public bool GameUpdate () { progress += Time.deltaTime; while (progress >= 1f) { tileFrom = tileTo; tileTo = tileTo.NextTileOnPath; positionFrom = positionTo; positionTo = tileTo.transform.localPosition; progress -= 1f; } transform.localPosition = Vector3.LerpUnclamped(positionFrom, positionTo, progress); return true; }

यह दुश्मनों को पथ का अनुसरण करने के लिए मजबूर करता है, लेकिन अंतिम बिंदु तक पहुंचने पर कार्य नहीं करेगा। इसलिए, From और To की स्थितियों को बदलने से पहले, आपको null साथ पथ पर अगले टाइल की तुलना करने की आवश्यकता है। यदि ऐसा है, तो हम अंतिम बिंदु पर पहुंच गए हैं और दुश्मन ने आंदोलन समाप्त कर दिया है। हम इसके लिए Reclaim निष्पादित करते हैं और false वापस आते हैं।

  while (progress >= 1f) { tileFrom = tileTo; tileTo = tileTo.NextTileOnPath; if (tileTo == null) { OriginFactory.Reclaim(this); return false; } positionFrom = positionTo; positionTo = tileTo.transform.localPosition; progress -= 1f; }

दुश्मन सबसे छोटा रास्ता अपनाते हैं।

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

दुश्मन बदलते रास्तों पर प्रतिक्रिया करते हैं।

एज टू एज मूवमेंट

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

आसन्न टाइलों के बीच का किनारा बिंदु उनके पदों के औसत से पाया जा सकता है। प्रत्येक दुश्मन के लिए हर कदम पर इसकी गणना करने के बजाय, हम केवल GameTile.GrowPathTo में पथ बदलते समय इसकी गणना करेंगे। ExitPoint संपत्ति का उपयोग करके इसे उपलब्ध ExitPoint ।

  public Vector3 ExitPoint { get; private set; } … GameTile GrowPathTo (GameTile neighbor) { … neighbor.ExitPoint = (neighbor.transform.localPosition + transform.localPosition) * 0.5f; return neighbor.Content.Type != GameTileContentType.Wall ? neighbor : null; }

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

  public void BecomeDestination () { distance = 0; nextOnPath = null; ExitPoint = transform.localPosition; }

Enemy बदलें ताकि यह निकास केंद्रों का उपयोग करे, न कि टाइल केंद्रों का।

  public bool GameUpdate () { progress += Time.deltaTime; while (progress >= 1f) { … positionTo = tileFrom.ExitPoint; progress -= 1f; } transform.localPosition = Vector3.Lerp(positionFrom, positionTo, progress); return true; } public void SpawnOn (GameTile tile) { … positionTo = tileFrom.ExitPoint; progress = 0f; }

दुश्मन किनारों के बीच चलते हैं।

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

मुड़ते समय दुश्मन रुक जाते हैं।

उन्मुखीकरण

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

हमारे पास चार दिशाएँ हैं: उत्तर, पूर्व, दक्षिण और पश्चिम। आइए हम उनकी गणना करें।

 public enum Direction { North, East, South, West }

फिर हम इसके पथ की दिशा को संग्रहीत करने के लिए GameTile गुण GameTile हैं।

  public Direction PathDirection { get; private set; }

GrowTo लिए एक दिशा पैरामीटर जोड़ें, जो संपत्ति सेट करता है। चूंकि हम शुरू से अंत तक एक रास्ता बढ़ा रहे हैं, इसलिए दिशा उस दिशा के विपरीत होगी जहां से हम आगे बढ़ रहे हैं।

  public GameTile GrowPathNorth () => GrowPathTo(north, Direction.South); public GameTile GrowPathEast () => GrowPathTo(east, Direction.West); public GameTile GrowPathSouth () => GrowPathTo(south, Direction.North); public GameTile GrowPathWest () => GrowPathTo(west, Direction.East); GameTile GrowPathTo (GameTile neighbor, Direction direction) { … neighbor.PathDirection = direction; return neighbor.Content.Type != GameTileContentType.Wall ? neighbor : null; }

हमें दिशाओं को quaternions के रूप में व्यक्त किए गए मोड़ में बदलने की आवश्यकता है। यह सुविधाजनक होगा यदि हम दिशा के लिए बस GetRotation को कॉल कर सकते हैं, तो चलो एक विस्तार विधि बनाकर ऐसा करते हैं। सामान्य स्थैतिक विधि DirectionExtensions जोड़ें, यह आवश्यक quaternions कैशिंग के लिए एक सरणी दे, साथ ही संबंधित दिशा मान वापस करने के लिए GetRotation विधि। इस स्थिति में, यह एक्सटेंशन क्लास को उसी प्रकार की फाइल में डालने के लिए समझ में आता है।

 using UnityEngine; public enum Direction { North, East, South, West } public static class DirectionExtensions { static Quaternion[] rotations = { Quaternion.identity, Quaternion.Euler(0f, 90f, 0f), Quaternion.Euler(0f, 180f, 0f), Quaternion.Euler(0f, 270f, 0f) }; public static Quaternion GetRotation (this Direction direction) { return rotations[(int)direction]; } }

विस्तार विधि क्या है?

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

क्या यह आपको किसी भी तरीके को जोड़ने की अनुमति देता है? हां, जैसा कि आप किसी भी स्थिर विधि को लिख सकते हैं जिसका पैरामीटर किसी भी प्रकार का है।

अब हम Enemy को घुमा सकते हैं और जब भी हम हर बार एक नई टाइल डालते हैं। डेटा को अपडेट करने के बाद, From टाइल हमें दिशा देता है।

  public bool GameUpdate () { progress += Time.deltaTime; while (progress >= 1f) { … transform.localRotation = tileFrom.PathDirection.GetRotation(); progress -= 1f; } transform.localPosition = Vector3.LerpUnclamped(positionFrom, positionTo, progress); return true; } public void SpawnOn (GameTile tile) { … transform.localRotation = tileFrom.PathDirection.GetRotation(); progress = 0f; }

दिशा का परिवर्तन

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

 public enum Direction { North, East, South, West } public enum DirectionChange { None, TurnRight, TurnLeft, TurnAround }

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

  public static DirectionChange GetDirectionChangeTo ( this Direction current, Direction next ) { if (current == next) { return DirectionChange.None; } else if (current + 1 == next || current - 3 == next) { return DirectionChange.TurnRight; } else if (current - 1 == next || current + 3 == next) { return DirectionChange.TurnLeft; } return DirectionChange.TurnAround; }

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

  public static float GetAngle (this Direction direction) { return (float)direction * 90f; }

अब आपको Enemyदिशा, दिशा और कोणों को बदलना होगा, जिसके बीच में आपको प्रक्षेप करने की आवश्यकता है।

  Direction direction; DirectionChange directionChange; float directionAngleFrom, directionAngleTo;

SpawnOnकठिन हो रहा है, तो चलिए राज्य तैयारी कोड को दूसरी विधि में स्थानांतरित करते हैं। हम दुश्मन के प्रारंभिक राज्य को एक परिचयात्मक राज्य के रूप में नामित करेंगे, इसलिए हम इसे कॉल करेंगे PrepareIntro। इस अवस्था में, दुश्मन केंद्र से अपनी प्रारंभिक टाइल के किनारे पर चला जाता है, इसलिए दिशा का कोई परिवर्तन नहीं होता है। कोण Fromऔर Toएक ही।

  public void SpawnOn (GameTile tile) { Debug.Assert(tile.NextTileOnPath != null, "Nowhere to go!", this); tileFrom = tile; tileTo = tile.NextTileOnPath; //positionFrom = tileFrom.transform.localPosition; //positionTo = tileFrom.ExitPoint; //transform.localRotation = tileFrom.PathDirection.GetRotation(); progress = 0f; PrepareIntro(); } void PrepareIntro () { positionFrom = tileFrom.transform.localPosition; positionTo = tileFrom.ExitPoint; direction = tileFrom.PathDirection; directionChange = DirectionChange.None; directionAngleFrom = directionAngleTo = direction.GetAngle(); transform.localRotation = direction.GetRotation(); }

इस स्तर पर, हम एक छोटे राज्य मशीन की तरह कुछ बनाते हैं। चीजों को सरल रखने के लिए GameUpdate, स्थिति कोड को एक नई विधि में स्थानांतरित करें PrepareNextState। हम केवल टाइलों के परिवर्तन को छोड़ देंगे Fromऔर To, क्योंकि हम उनका उपयोग यहां यह जांचने के लिए करते हैं कि क्या दुश्मन ने रास्ता खत्म कर दिया है।

  public bool GameUpdate () { progress += Time.deltaTime; while (progress >= 1f) { … //positionFrom = positionTo; //positionTo = tileFrom.ExitPoint; //transform.localRotation = tileFrom.PathDirection.GetRotation(); progress -= 1f; PrepareNextState(); } … }

एक नए राज्य में संक्रमण करते समय, आपको हमेशा पदों को बदलने, दिशा बदलने, वर्तमान दिशा को अपडेट करने और कोण Toको स्थानांतरित करने की आवश्यकता होती है From। हमने अब कोई टर्न नहीं लिया है।

  void PrepareNextState () { positionFrom = positionTo; positionTo = tileFrom.ExitPoint; directionChange = direction.GetDirectionChangeTo(tileFrom.PathDirection); direction = tileFrom.PathDirection; directionAngleFrom = directionAngleTo; }

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

  void PrepareForward () { transform.localRotation = direction.GetRotation(); directionAngleTo = direction.GetAngle(); }

एक मोड़ के मामले में, हम तुरंत नहीं मुड़ते हैं। हमें एक अलग कोण पर प्रक्षेपित करने की आवश्यकता है: दाएं मुड़ने के लिए 90 ° अधिक, बाएं मुड़ने के लिए 90 ° कम, और वापस मुड़ने के लिए 180 ° अधिक। 359 ° से 0 ° के कोण मूल्यों में परिवर्तन के कारण गलत दिशा में मोड़ से बचने के लिए, कोण Toको वर्तमान दिशा के सापेक्ष संकेत दिया जाना चाहिए। हमें यह चिंता करने की आवश्यकता नहीं है कि कोण 0 ° से कम या 360 ° से अधिक हो जाएगा, क्योंकि हम Quaternion.Eulerइसे संभाल सकते हैं।

  void PrepareTurnRight () { directionAngleTo = directionAngleFrom + 90f; } void PrepareTurnLeft () { directionAngleTo = directionAngleFrom - 90f; } void PrepareTurnAround () { directionAngleTo = directionAngleFrom + 180f; }

अंत में, PrepareNextStateहम यह switchतय करने के लिए कि किन चार तरीकों को कॉल करने के लिए दिशाओं का उपयोग कर सकते हैं ।

  void PrepareNextState () { … switch (directionChange) { case DirectionChange.None: PrepareForward(); break; case DirectionChange.TurnRight: PrepareTurnRight(); break; case DirectionChange.TurnLeft: PrepareTurnLeft(); break; default: PrepareTurnAround(); break; } }

अब अंत में GameUpdateहमें यह जांचने की आवश्यकता है कि क्या दिशा बदल गई है। यदि ऐसा है, तो दो कोनों के बीच इंटरपोलेट करें और घुमाव सेट करें।

  public bool GameUpdate () { … transform.localPosition = Vector3.LerpUnclamped(positionFrom, positionTo, progress); if (directionChange != DirectionChange.None) { float angle = Mathf.LerpUnclamped( directionAngleFrom, directionAngleTo, progress ); transform.localRotation = Quaternion.Euler(0f, angle, 0f); } return true; }

दुश्मन पलट रहे हैं।

वक्र आंदोलन

हम दुश्मनों को मोड़ते समय एक घुमाव के साथ गति को बेहतर बना सकते हैं। टाइल के किनारे से किनारे तक चलने के बजाय, उन्हें एक सर्कल के एक चौथाई चलने दें। टाइल्स के कोने आम में इस मंडली झूठ का केंद्र Fromऔर Toजिस पर दुश्मन टाइल पर दर्ज किया गया एक ही किनारे पर, From।

दाईं ओर मुड़ने के लिए एक चौथाई वृत्त रोटेशन।

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

  [SerializeField] Transform model = default;

मॉडल के संदर्भ में दुश्मन।

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

  void PrepareForward () { transform.localRotation = direction.GetRotation(); directionAngleTo = direction.GetAngle(); model.localPosition = Vector3.zero; } void PrepareTurnRight () { directionAngleTo = directionAngleFrom + 90f; model.localPosition = new Vector3(-0.5f, 0f); } void PrepareTurnLeft () { directionAngleTo = directionAngleFrom - 90f; model.localPosition = new Vector3(0.5f, 0f); } void PrepareTurnAround () { directionAngleTo = directionAngleFrom + 180f; model.localPosition = Vector3.zero; }

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

  static Vector3[] halfVectors = { Vector3.forward * 0.5f, Vector3.right * 0.5f, Vector3.back * 0.5f, Vector3.left * 0.5f }; … public static Vector3 GetHalfVector (this Direction direction) { return halfVectors[(int)direction]; }

दाएं या बाएं मुड़ते समय संबंधित वेक्टर जोड़ें।

  void PrepareTurnRight () { directionAngleTo = directionAngleFrom + 90f; model.localPosition = new Vector3(-0.5f, 0f); transform.localPosition = positionFrom + direction.GetHalfVector(); } void PrepareTurnLeft () { directionAngleTo = directionAngleFrom - 90f; model.localPosition = new Vector3(0.5f, 0f); transform.localPosition = positionFrom + direction.GetHalfVector(); }

और जब पीछे मुड़ते हैं, तो स्थिति सामान्य शुरुआती बिंदु होनी चाहिए।

  void PrepareTurnAround () { directionAngleTo = directionAngleFrom + 180f; model.localPosition = Vector3.zero; transform.localPosition = positionFrom; }

इसके अलावा, निकास बिंदु की गणना करते समय, हम GameTile.GrowPathToआधे वेक्टर का उपयोग कर सकते हैं, ताकि हमें टाइल्स के दो पदों तक पहुंच की आवश्यकता न हो।

  neighbor.ExitPoint = neighbor.transform.localPosition + direction.GetHalfVector();

अब, जब दिशाएं बदल रही हैं, तो हमें स्थिति को बीच में लाने की ज़रूरत नहीं है Enemy.GameUpdate, क्योंकि घुमाव आंदोलन में लगा हुआ है।

  public bool GameUpdate () { … if (directionChange == DirectionChange.None) { transform.localPosition = Vector3.LerpUnclamped(positionFrom, positionTo, progress); } //if (directionChange != DirectionChange.None) { else { float angle = Mathf.LerpUnclamped( directionAngleFrom, directionAngleTo, progress ); transform.localRotation = Quaternion.Euler(0f, angle, 0f); } return true; }

दुश्मन आसानी से कोनों के चारों ओर झुकते हैं।

लगातार गति

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

  float progress, progressFactor; … public bool GameUpdate () { progress += Time.deltaTime * progressFactor; … }

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

  public bool GameUpdate () { progress += Time.deltaTime * progressFactor; while (progress >= 1f) { … //progress -= 1f; progress = (progress - 1f) / progressFactor; PrepareNextState(); progress *= progressFactor; } … }

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

  void PrepareForward () { … progressFactor = 1f; } void PrepareTurnRight () { … progressFactor = 1f / (Mathf.PI * 0.25f); } void PrepareTurnLeft () { … progressFactor = 1f / (Mathf.PI * 0.25f); } void PrepareTurnAround () { … progressFactor = 2f; } void PrepareIntro () { … progressFactor = 2f; }

दूरी 1/4 * पाई के बराबर क्यों है?

2π, . , ½, ½π × ½.

अंतिम स्थिति

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

  void PrepareOutro () { positionTo = tileFrom.transform.localPosition; directionChange = DirectionChange.None; directionAngleTo = direction.GetAngle(); model.localPosition = Vector3.zero; transform.localRotation = direction.GetRotation(); progressFactor = 2f; }

आदेश में GameUpdateदुश्मन भी टाइल्स पारी को हटाने के द्वारा जल्दी नष्ट करने के लिए नहीं। अब वे लगे हुए किया जाएगा PrepareNextState। इस प्रकार, अंतिम राज्य की समाप्ति के बाद ही nullरिटर्न की जाँच करना true।

  public bool GameUpdate () { progress += Time.deltaTime * progressFactor; while (progress >= 1f) { //tileFrom = tileTo; //tileTo = tileTo.NextTileOnPath; if (tileTo == null) { OriginFactory.Reclaim(this); return false; } … } … }

जैसा कि PrepareNextStateहम टाइल्स शिफ्ट करने के लिए शुरू करते हैं। फिर, स्थिति निर्धारित करने के बाद From, लेकिन स्थिति निर्धारित करने से पहले, Toहम जाँचेंगे कि क्या टाइल Toमूल्य के बराबर है null। यदि ऐसा है, तो अंतिम स्थिति तैयार करें और बाकी विधि छोड़ें।

  void PrepareNextState () { tileFrom = tileTo; tileTo = tileTo.NextTileOnPath; positionFrom = positionTo; if (tileTo == null) { PrepareOutro(); return; } positionTo = tileFrom.ExitPoint; … }

एक निरंतर गति और अंतिम स्थिति के साथ दुश्मन।

शत्रु भिन्नता

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

फ्लोट वैल्यू रेंज

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

 using UnityEngine; [System.Serializable] public struct FloatRange { [SerializeField] float min, max; public float Min => min; public float Max => max; public float RandomValueInRange { get { return Random.Range(min, max); } } public FloatRange(float value) { min = max = value; } public FloatRange (float min, float max) { this.min = min; this.max = max < min ? min : max; } }

हम इसके अंतराल को सीमित करने के लिए इसमें निर्धारित विशेषता को भी कॉपी करते हैं।

 using UnityEngine; public class FloatRangeSliderAttribute : PropertyAttribute { public float Min { get; private set; } public float Max { get; private set; } public FloatRangeSliderAttribute (float min, float max) { Min = min; Max = max < min ? min : max; } }

हमें केवल स्लाइडर के दृश्य की आवश्यकता है, इसलिए इसे संपादकFloatRangeSliderDrawer फ़ोल्डर में कॉपी करें ।

 using UnityEditor; using UnityEngine; [CustomPropertyDrawer(typeof(FloatRangeSliderAttribute))] public class FloatRangeSliderDrawer : PropertyDrawer { public override void OnGUI ( Rect position, SerializedProperty property, GUIContent label ) { int originalIndentLevel = EditorGUI.indentLevel; EditorGUI.BeginProperty(position, label, property); position = EditorGUI.PrefixLabel( position, GUIUtility.GetControlID(FocusType.Passive), label ); EditorGUI.indentLevel = 0; SerializedProperty minProperty = property.FindPropertyRelative("min"); SerializedProperty maxProperty = property.FindPropertyRelative("max"); float minValue = minProperty.floatValue; float maxValue = maxProperty.floatValue; float fieldWidth = position.width / 4f - 4f; float sliderWidth = position.width / 2f; position.width = fieldWidth; minValue = EditorGUI.FloatField(position, minValue); position.x += fieldWidth + 4f; position.width = sliderWidth; FloatRangeSliderAttribute limit = attribute as FloatRangeSliderAttribute; EditorGUI.MinMaxSlider( position, ref minValue, ref maxValue, limit.Min, limit.Max ); position.x += sliderWidth + 4f; position.width = fieldWidth; maxValue = EditorGUI.FloatField(position, maxValue); if (minValue < limit.Min) { minValue = limit.Min; } if (maxValue < minValue) { maxValue = minValue; } else if (maxValue > limit.Max) { maxValue = limit.Max; } minProperty.floatValue = minValue; maxProperty.floatValue = maxValue; EditorGUI.EndProperty(); EditorGUI.indentLevel = originalIndentLevel; } }

मॉडल का पैमाना

हम दुश्मन के पैमाने को बदलकर शुरू करेंगे। EnemyFactoryविकल्प में स्केल सेटिंग्स जोड़ें । पैमाने का अंतराल बहुत बड़ा नहीं होना चाहिए, लेकिन दुश्मनों की लघु और विशाल किस्मों को बनाने के लिए पर्याप्त है। मानक मान के साथ 0.5-2 के भीतर कुछ भी। हम इस अंतराल में एक यादृच्छिक पैमाने का चयन करेंगे Getऔर इसे एक नई विधि के माध्यम से दुश्मन को पास करेंगे Initialize।

  [SerializeField, FloatRangeSlider(0.5f, 2f)] FloatRange scale = new FloatRange(1f); public Enemy Get () { Enemy instance = CreateGameObjectInstance(prefab); instance.OriginFactory = this; instance.Initialize(scale.RandomValueInRange); return instance; }

विधि Enemy.Initializeबस अपने मॉडल के पैमाने को निर्धारित करती है जो सभी आयामों में समान है।

  public void Initialize (float scale) { model.localScale = new Vector3(scale, scale, scale); }

तराजू की सीमा 0.5 से 1.5 तक है।

पथ ऑफसेट

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

  [SerializeField, FloatRangeSlider(-0.4f, 0.4f)] FloatRange pathOffset = new FloatRange(0f); public Enemy Get () { Enemy instance = CreateGameObjectInstance(prefab); instance.OriginFactory = this; instance.Initialize( scale.RandomValueInRange, pathOffset.RandomValueInRange ); return instance; }

चूंकि मार्ग का विस्थापन यात्रा के मार्ग को प्रभावित करता है, Enemyइसलिए इसे ट्रैक करना आवश्यक है।

  float pathOffset; … public void Initialize (float scale, float pathOffset) { model.localScale = new Vector3(scale, scale, scale); this.pathOffset = pathOffset; }

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

  void PrepareForward () { transform.localRotation = direction.GetRotation(); directionAngleTo = direction.GetAngle(); model.localPosition = new Vector3(pathOffset, 0f); progressFactor = 1f; } void PrepareTurnRight () { directionAngleTo = directionAngleFrom + 90f; model.localPosition = new Vector3(pathOffset - 0.5f, 0f); transform.localPosition = positionFrom + direction.GetHalfVector(); progressFactor = 1f / (Mathf.PI * 0.25f); } void PrepareTurnLeft () { directionAngleTo = directionAngleFrom - 90f; model.localPosition = new Vector3(pathOffset + 0.5f, 0f); transform.localPosition = positionFrom + direction.GetHalfVector(); progressFactor = 1f / (Mathf.PI * 0.25f); } void PrepareTurnAround () { directionAngleTo = directionAngleFrom + 180f; model.localPosition = new Vector3(pathOffset, 0f); transform.localPosition = positionFrom; progressFactor = 2f; } void PrepareIntro () { … model.localPosition = new Vector3(pathOffset, 0f); transform.localRotation = direction.GetRotation(); progressFactor = 2f; } void PrepareOutro () { … model.localPosition = new Vector3(pathOffset, 0f); transform.localRotation = direction.GetRotation(); progressFactor = 2f; }

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

  void PrepareTurnRight () { … progressFactor = 1f / (Mathf.PI * 0.5f * (0.5f - pathOffset)); } void PrepareTurnLeft () { … progressFactor = 1f / (Mathf.PI * 0.5f * (0.5f + pathOffset)); }

180 ° मुड़ने पर हमें मोड़ त्रिज्या भी मिलता है। इस मामले में, हम पथ के ऑफसेट के बराबर त्रिज्या के साथ आधा सर्कल को कवर करते हैं, इसलिए दूरी ऑफसेट से cover गुना है। हालांकि, यह तब काम नहीं करता है जब विस्थापन शून्य हो, और छोटे विस्थापन पर, मोड़ बहुत तेज हो। त्वरित मोड़ से बचने के लिए, हम न्यूनतम त्रिज्या को गति की गणना करने के लिए मजबूर कर सकते हैं, 0.2 कह सकते हैं।

  void PrepareTurnAround () { directionAngleTo = directionAngleFrom + (pathOffset < 0f ? 180f : -180f); model.localPosition = new Vector3(pathOffset, 0f); transform.localPosition = positionFrom; progressFactor = 1f / (Mathf.PI * Mathf.Max(Mathf.Abs(pathOffset), 0.2f)); }

पथ ऑफ़सेट −0.25–0.25 सीमा में है।

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

दुश्मनों को पड़ोसी टाइलों तक पहुंचने से रोकने के लिए, किसी को अपने अधिकतम संभव पैमाने को भी ध्यान में रखना चाहिए। मैंने आकार को केवल 1 के अधिकतम मूल्य तक सीमित कर दिया है, इसलिए घन के लिए अधिकतम स्वीकार्य ऑफसेट 0.25 है। यदि अधिकतम आकार 1.5 था, तो अधिकतम विस्थापन 0.125 तक कम किया जाना चाहिए।

गति

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

  [SerializeField, FloatRangeSlider(0.2f, 5f)] FloatRange speed = new FloatRange(1f); [SerializeField, FloatRangeSlider(-0.4f, 0.4f)] FloatRange pathOffset = new FloatRange(0f); public Enemy Get () { Enemy instance = CreateGameObjectInstance(prefab); instance.OriginFactory = this; instance.Initialize( scale.RandomValueInRange, speed.RandomValueInRange, pathOffset.RandomValueInRange ); return instance; }

अब मुझे Enemyट्रैक और स्पीड करनी है।

  float speed; … public void Initialize (float scale, float speed, float pathOffset) { model.localScale = new Vector3(scale, scale, scale); this.speed = speed; this.pathOffset = pathOffset; }

जब हमने स्पष्ट रूप से गति निर्धारित नहीं की थी, तो हमने बस हमेशा मूल्य का उपयोग किया था। अब हमें केवल गति पर प्रगति गुणक की निर्भरता बनाने की आवश्यकता है।

  void PrepareForward () { … progressFactor = speed; } void PrepareTurnRight () { … progressFactor = speed / (Mathf.PI * 0.5f * (0.5f - pathOffset)); } void PrepareTurnLeft () { … progressFactor = speed / (Mathf.PI * 0.5f * (0.5f + pathOffset)); } void PrepareTurnAround () { … progressFactor = speed / (Mathf.PI * Mathf.Max(Mathf.Abs(pathOffset), 0.2f)); } void PrepareIntro () { … progressFactor = 2f * speed; } void PrepareOutro () { … progressFactor = 2f * speed; }

रेंज में गति 0.75-1.25।

इसलिए, हमें दुश्मनों की एक सुंदर धारा मिल गई जो अंतिम बिंदु पर जा रही थी। अगले ट्यूटोरियल में हम जानेंगे कि इनसे कैसे निपटा जाए। जानना चाहेंगे कि यह कब रिलीज होगी? Patreon पर मेरे पेज का पालन करें !

रिपॉजिटरी

पीडीएफ लेख

एकता में टॉवर रक्षा बनाना: दुश्मन