एकता में टॉवर रक्षा बनाना: टावर्स और शूटिंग दुश्मन

[ट्यूटोरियल का पहला और दूसरा भाग]

• हम टॉवर के मैदान पर जगह बनाते हैं।
• हम भौतिकी की मदद से दुश्मनों को निशाना बनाते हैं।
• हम उन्हें ट्रैक करते हैं जबकि यह संभव है।
• हम उन्हें एक लेजर बीम के साथ शूट करते हैं।

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

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


दुश्मनों को गर्मी दें।

टॉवर निर्माण

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

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

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

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

इस ट्यूटोरियल में, हम केवल एक ही प्रकार के टॉवर का समर्थन करेंगे, जिसे GameTileContentFactory को टॉवर GameTileContentFactory एक लिंक के GameTileContentFactory प्रदान करके कार्यान्वित किया जा सकता है, जिसका एक उदाहरण Get के माध्यम से भी बनाया जा सकता है।

  [SerializeField] GameTileContent towerPrefab = default; public GameTileContent Get (GameTileContentType type) { switch (type) { … case GameTileContentType.Tower€: return Get(towerPrefab); } … } 

लेकिन टावरों को शूट करना होगा, इसलिए उनकी स्थिति को अद्यतन करने की आवश्यकता होगी और उन्हें अपने कोड की आवश्यकता होगी। इस उद्देश्य के लिए एक Tower क्लास बनाएं जो GameTileContent क्लास का विस्तार करता है।

 using UnityEngine; public class Tower : GameTileContent {} 

आप कारखाने के मैदान के प्रकार को Tower बदलकर टॉवर प्रीफैब का अपना घटक बना सकते हैं। चूँकि वर्ग को अभी भी एक GameTileContent माना जाता है, इसलिए कुछ और बदलने की आवश्यकता नहीं है।

  Tower towerPrefab = default; 

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

टॉवर के लिए एक प्रीफैब बनाएं। आप दीवार GameTileContent को डुप्लिकेट करके और इसके GameTileContent घटक को Tower घटक के साथ बदलकर शुरू कर सकते हैं, और फिर इसके प्रकार को टॉवर में बदल सकते हैं। टॉवर को दीवारों को फिट करने के लिए, टॉवर के आधार के रूप में दीवार क्यूब को बचाएं। फिर उसके ऊपर एक और क्यूब रखें। मैंने उसे 0.5 का पैमाना दिया। उस पर एक और क्यूब रखो, एक बुर्ज का संकेत देते हुए, यह हिस्सा दुश्मनों पर निशाना लगाएगा और गोली मार देगा।



एक टावर बनाने वाले तीन क्यूब्स।

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



कोलाइडर घन टॉवर।

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



एक लेजर बीम का छिपा हुआ घन।

लेजर बीम के लिए एक उपयुक्त सामग्री बनाएं। मैंने केवल मानक पारभासी काली सामग्री का उपयोग किया और सभी प्रतिबिंबों को बंद कर दिया, और इसे एक लाल उत्सर्जित रंग भी दिया।



लेजर बीम की सामग्री।

जाँच करें कि लेजर बीम में कोलाइडर नहीं है, और इसके कास्ट और छाया को भी बंद कर दें।


लेज़र बीम शैडो से इंटरैक्ट नहीं करता है।

टॉवर प्रीफैब के निर्माण को पूरा करने के बाद, हम इसे कारखाने में जोड़ देंगे।


टावर के साथ फैक्टरी।

टॉवर प्लेसमेंट

हम एक और स्विचिंग विधि का उपयोग करके टावरों को जोड़ेंगे और निकालेंगे। आप बस विधि नाम और सामग्री प्रकार को बदलकर GameBoard.ToggleWall नकल कर सकते हैं।

  public void ToggleTower (GameTile tile) { if (tile.Content.Type == GameTileContentType.Tower€) { tile.Content = contentFactory.Get(GameTileContentType.Empty); FindPaths(); } else if (tile.Content.Type == GameTileContentType.Empty) { tile.Content = contentFactory.Get(GameTileContentType.Tower€); if (!FindPaths()) { tile.Content = contentFactory.Get(GameTileContentType.Empty); FindPaths(); } } } 

Game.HandleTouch , शिफ्ट की को पकड़कर दीवारों की बजाय टावरों को स्विच किया जाएगा।

  void HandleTouch () { GameTile tile = board.GetTile(TouchRay); if (tile != null) { if (Input.GetKey(KeyCode.LeftShift)) { board.ToggleTower(tile); } else { board.ToggleWall(tile); } } } 

मैदान पर टावर्स।

पथ अवरुद्ध

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

  public bool BlocksPath => Type == GameTileContentType.Wall || Type == GameTileContentType.Tower€; 

सामग्री प्रकार की जाँच करने के बजाय GameTile.GrowPathTo में इस गुण का उपयोग करें।

  GameTile GrowPathTo (GameTile neighbor, Direction direction) { … return //neighbor.Content.Type != GameTileContentType.Wall ? neighbor : null; neighbor.Content.BlocksPath ? null : neighbor; } 

अब पथ दीवारों और टावरों द्वारा अवरुद्ध है।

दीवारों की जगह

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

  public void ToggleTower (GameTile tile) { if (tile.Content.Type == GameTileContentType.Tower) { tile.Content = contentFactory.Get(GameTileContentType.Empty); FindPaths(); } else if (tile.Content.Type == GameTileContentType.Empty) { … } else if (tile.Content.Type == GameTileContentType.Wall) { tile.Content = contentFactory.Get(GameTileContentType.Tower); } } 

हम दुश्मनों को निशाना बनाते हैं

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

लक्ष्य की ओर इशारा करते हुए

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

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

 using UnityEngine; public class TargetPoint : MonoBehaviour { public Enemy Enemy€ { get; private set; } public Vector3 Position => transform.position; } 

आइए इसे एक Awake विधि दें जो अपने Enemy घटक के लिए एक लिंक स्थापित करता है। transform.root का उपयोग करके सीधे रूट ऑब्जेक्ट पर जाएं। यदि Enemy घटक मौजूद नहीं है, तो हमने दुश्मन बनाते समय एक गलती की है, तो आइए इसके लिए एक बयान जोड़ें।

  void Awake () { Enemy€ = transform.root.GetComponent<Enemy>(); Debug.Assert(Enemy€ != null, "Target point without Enemy root!", this); } 

इसके अलावा, कोलाइडर को उसी गेम ऑब्जेक्ट से जोड़ा जाना चाहिए, जिससे TargetPoint जुड़ा हुआ है।

  Debug.Assert(Enemy€ != null, "Target point without Enemy root!", this); Debug.Assert( GetComponent<SphereCollider>() != null, "Target point without sphere collider!", this ); 

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



एक लक्ष्य बिंदु के साथ एक दुश्मन और एक घन पर एक कोलाइडर।

शत्रु परत

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


लेयर 9 का इस्तेमाल दुश्मनों के लिए किया जाएगा।

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


परत की टकराव की मैट्रिक्स।

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


सही परत पर दुश्मन।

चलिए इस कथन को TargetPoint कि TargetPoint वास्तव में सही परत पर है।

  void Awake () { … Debug.Assert(gameObject.layer == 9, "Target point on wrong layer!", this); } 

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

  public GameTile GetTile (Ray ray) { if (Physics.Raycast(ray, out RaycastHit hit, float.MaxValue, 1)) { … } return null; } 

अद्यतन टाइल सामग्री

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

  public virtual void GameUpdate () {} 

चलो Tower फिर से परिभाषित करते हैं, भले ही अभी के लिए यह केवल कंसोल में प्रदर्शित करता है कि यह एक लक्ष्य की तलाश में है।

  public override void GameUpdate () { Debug.Log("Searching for target..."); } 

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

  List<GameTileContent> updatingContent = new List<GameTileContent>(); … public void GameUpdate () { for (int i = 0; i < updatingContent.Count; i++) { updatingContent[i].GameUpdate(); } } 

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

  public void ToggleTower (GameTile tile) { if (tile.Content.Type == GameTileContentType.Tower) { updatingContent.Remove(tile.Content); tile.Content = contentFactory.Get(GameTileContentType.Empty); FindPaths(); } else if (tile.Content.Type == GameTileContentType.Empty) { tile.Content = contentFactory.Get(GameTileContentType.Tower); //if (!FindPaths()) { if (FindPaths()) { updatingContent.Add(tile.Content); } else { tile.Content = contentFactory.Get(GameTileContentType.Empty); FindPaths(); } } else if (tile.Content.Type == GameTileContentType.Wall) { tile.Content = contentFactory.Get(GameTileContentType.Tower); updatingContent.Add(tile.Content); } } 

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

  void Update () { … enemies.GameUpdate(); board.GameUpdate(); } 

लक्ष्य की सीमा

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

  [SerializeField, Range(1.5f, 10.5f)] float targetingRange = 1.5f; 

सीमा 2.5 का लक्ष्य।

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

  void OnDrawGizmosSelected () { Gizmos.color = Color.yellow; Vector3 position = transform.localPosition; position.y += 0.01f; Gizmos.DrawWireSphere(position, targetingRange); } 

Gizmo लक्ष्य सीमा।

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

 [SelectionBase] public class GameTileContent : MonoBehaviour { … } 

लक्ष्य पर कब्जा

Tower क्लास में एक TargetPoint फील्ड जोड़ें ताकि वह अपने कब्जे वाले लक्ष्य को ट्रैक कर सके। फिर हम नई AquireTarget पद्धति को कॉल GameUpdate को GameUpdate , जो लक्ष्य के बारे में जानकारी प्राप्त करता है। पता लगाने पर, यह कंसोल में एक संदेश प्रदर्शित करेगा।

  TargetPoint target; public override void GameUpdate () { if (AcquireTarget()) { Debug.Log("Acquired target!"); } } 

AcquireTarget हम AcquireTarget को एक टावर की स्थिति और तर्कों के रूप में सीमा पर कॉल करके सभी उपलब्ध लक्ष्य प्राप्त करते हैं। इसका परिणाम एक Collider सरणी होगा जिसमें सभी Collider गोला के संपर्क में होंगे। यदि सरणी की लंबाई सकारात्मक है, तो कम से कम एक लक्ष्य बिंदु है, और हम बस पहले का चयन करते हैं। इसका TargetPoint घटक लें, जो हमेशा मौजूद होना चाहिए, इसे लक्ष्य क्षेत्र में असाइन करें और सफलता की रिपोर्ट करें। अन्यथा, हम लक्ष्य को साफ़ करते हैं और विफलता की रिपोर्ट करते हैं।

  bool AcquireTarget () { Collider[] targets = Physics.OverlapSphere( transform.localPosition, targetingRange ); if (targets.Length > 0) { target = targets[0].GetComponent<TargetPoint>(); Debug.Assert(target != null, "Targeted non-enemy!", targets[0]); return true; } target = null; return false; } 

हम सही लक्ष्य बिंदु प्राप्त करने की गारंटी देते हैं, अगर हम केवल दुश्मनों की परत पर कोलाडर को ध्यान में रखते हैं। यह लेयर 9 है, इसलिए हम संबंधित लेयर मास्क को पास करेंगे।

  const int enemyLayerMask = 1 << 9; … bool AcquireTarget () { Collider[] targets = Physics.OverlapSphere( transform.localPosition, targetingRange, enemyLayerMask ); … } 

आप टॉवर और लक्ष्य की स्थिति के बीच एक उपयोगी रेखा खींचकर कैप्चर किए गए लक्ष्य की कल्पना कर सकते हैं।

  void OnDrawGizmosSelected () { … if (target != null) { Gizmos.DrawLine(position, target.Position); } } 

लक्ष्यों का दृश्य।

टारगेट लॉक

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

  bool TrackTarget () { if (target == null) { return false; } return true; } 

हम GameUpdate में इस विधि को कॉल करेंगे और केवल तभी जब हम वापस लौटेंगे, हम AcquireTarget कॉल AcquireTarget । यदि विधि सही है, तो हमारे पास एक लक्ष्य है। यह ओआर ऑपरेटर के साथ एक चेक चेक में दोनों विधि कॉल रखकर किया जा सकता है, क्योंकि यदि पहला ऑपरेंड true , तो दूसरा चेक नहीं किया जाएगा, और कॉल मिस हो जाएगी। AND ऑपरेटर समान तरीके से कार्य करता है।

  public override void GameUpdate () { if (TrackTarget() || AcquireTarget()) { Debug.Log("Locked on target!"); } } 

ट्रैकिंग लक्ष्य।

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

लक्ष्य को ट्रैक करने के लिए जब वे सीमा के भीतर होते हैं, तो TrackTarget को टॉवर और लक्ष्य के बीच की दूरी को ट्रैक करना चाहिए। यदि यह सीमा मान से अधिक है, तो लक्ष्य को रीसेट करना होगा और गलत लौटना होगा। आप इस जांच के लिए Vector3.Distance विधि का उपयोग कर सकते हैं।

  bool TrackTarget () { if (target == null) { return false; } Vector3 a = transform.localPosition; Vector3 b = target.Position; if (Vector3.Distance(a, b) > targetingRange) { target = null; return false; } return true; } 

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

  if (Vector3.Distance(a, b) > targetingRange + 0.125f) { … } 

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

  public float Scale { get; private set; } … public void Initialize (float scale, float speed, float pathOffset) { Scale = scale; … } 

अब हम Tower.TrackTarget में सही रेंज की जांच कर सकते हैं।

  if (Vector3.Distance(a, b) > targetingRange + 0.125f * target.Enemy€.Scale) { … } 

हम भौतिकी को सिंक्रनाइज़ करते हैं

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


गलत निशाना लगाना।

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

जब आप Physics.autoSyncTransforms ट्रांसफ़ॉर्मेशन सेट करके ऑब्जेक्ट ट्रांसफ़ॉर्मेशन को पूरा करते हैं, तो आप तात्कालिक सिंक्रनाइज़ेशन सक्षम कर सकते हैं। लेकिन डिफ़ॉल्ट रूप से यह अक्षम है, क्योंकि यह सब कुछ एक साथ और यदि आवश्यक हो तो सिंक्रनाइज़ करने के लिए बहुत अधिक कुशल है। हमारे मामले में, केवल टावरों की स्थिति को अपडेट करते समय सिंक्रनाइज़ेशन की आवश्यकता होती है। हम Game.Update में दुश्मन और क्षेत्र अपडेट के बीच Game.Update को कॉल करके इसे निष्पादित कर सकते हैं।

  void Update () { … enemies.GameUpdate(); Physics.SyncTransforms(); board.GameUpdate(); } 

ऊँचाई पर ध्यान न दें

वास्तव में, हमारा गेमप्ले 2 डी में होता है। इसलिए, Tower बदल दें ताकि जब लक्ष्य करना और उस पर नज़र रखना केवल एक्स और जेड निर्देशांक को AcquireTarget में AcquireTarget । भौतिक इंजन 3 डी अंतरिक्ष में काम करता है, लेकिन संक्षेप में हम 2 डी में AcquireTarget का प्रदर्शन कर सकते हैं: गोलाकार को ऊपर खींचें ताकि यह सभी कोलाइडर को ध्यान में रखते हुए, हो सके। उनकी ऊर्ध्वाधर स्थिति से। यह एक गोले के बजाय एक कैप्सूल का उपयोग करके किया जा सकता है, जिसका दूसरा बिंदु जमीन के ऊपर कई इकाइयां होंगी (उदाहरण के लिए, तीन)।

  bool AcquireTarget () { Vector3 a = transform.localPosition; Vector3 b = a; by += 3f; Collider[] targets = Physics.OverlapCapsule( a, b, targetingRange, enemyLayerMask ); … } 

TrackTarget . , 2D- Vector2.Distance , , . .

  bool TrackTarget () { if (target == null) { return false; } Vector3 a = transform.localPosition; Vector3 b = target.Position; float x = ax - bx; float z = az - bz; float r = targetingRange + 0.125f * target.Enemy€.Scale; if (x * x + z * z > r * r) { target = null; return false; } return true; } 

Physics.OverlapCapsule , . , OverlapCapsuleNonAlloc . . . , 1.

OverlapCapsuleNonAlloc , , .

  static Collider[] targetsBuffer = new Collider[1]; … bool AcquireTarget () { Vector3 a = transform.localPosition; Vector3 b = a; by += 2f; int hits = Physics.OverlapCapsuleNonAlloc( a, b, targetingRange, targetsBuffer, enemyLayerMask ); if (hits > 0) { target = targetsBuffer[0].GetComponent<TargetPoint>(); Debug.Assert(target != null, "Targeted non-enemy!", targetsBuffer[0]); return true; } target = null; return false; } 

, , . , .

, Tower Transform . .

  [SerializeField] Transform turret = default; 

.

GameUpdate , . . , Transform.LookAt .

  public override void GameUpdate () { if (TrackTarget() || AcquireTarget()) { //Debug.Log("Locked on target!"); Shoot(); } } void Shoot () { Vector3 point = target.Position; turret.LookAt(point); } 

.

Tower .

  [SerializeField] Transform turret = default, laserBeam = default; 

.

, . -, . , .

  void Shoot () { Vector3 point = target.Position; turret.LookAt(point); laserBeam.localRotation = turret.localRotation; } 

- , . Z, , . XY, (Awake) .

  Vector3 laserBeamScale; void Awake () { laserBeamScale = laserBeam.localScale; } … void Shoot () { Vector3 point = target.Position; turret.LookAt(point); laserBeam.localRotation = turret.localRotation; float d = Vector3.Distance(turret.position, point); laserBeamScale.z = d; laserBeam.localScale = laserBeamScale; } 

-, .

  laserBeam.localScale = laserBeamScale; laserBeam.localPosition = turret.localPosition + 0.5f * d * laserBeam.forward; 

.


, . , . , GameUpdate 0.

  public override void GameUpdate () { if (TrackTarget() || AcquireTarget()) { Shoot(); } else { laserBeam.localScale = Vector3.zero; } } 

.

. , . , Enemy . , 100. , , .

  float Health { get; set; } … public void Initialize (float scale, float speed, float pathOffset) { … Health = 100f * scale; } 

, ApplyDamage , . , , .

  public void ApplyDamage (float damage) { Debug.Assert(damage >= 0f, "Negative damage applied."); Health -= damage; } 

, . GameUpdate .

  public bool GameUpdate () { if (Health <= 0f) { OriginFactory.Reclaim(this); return false; } … } 

, , , , .

, . Tower . , (damage per second). Shoot Enemy .

  [SerializeField, Range(1f, 100f)] float damagePerSecond = 10f; … void Shoot () { … target.Enemy.ApplyDamage(damagePerSecond * Time.deltaTime); } 

— 20 .

, , . , , , . , .

, , . , , 100. , , .

  static Collider[] targetsBuffer = new Collider[100]; 

.

  bool AcquireTarget () { … if (hits > 0) { target = targetsBuffer[Random.Range(0, hits)].GetComponent<TargetPoint>(); … } target = null; return false; } 

.


, « » - . .