🦈 📈 🤚🏻 एकता में टॉवर रक्षा बनाना: बैलिस्टिक्स 🤷🏻 🦂 👨🏻‍🎤

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

विभिन्न प्रकार के टावरों के लिए समर्थन।
मोर्टार टॉवर बनाना।
परवलयिक प्रक्षेपवक्र की गणना।
विस्फोट के गोले लॉन्च करना।

यह एक साधारण टॉवर रक्षा खेल बनाने पर एक ट्यूटोरियल का चौथा भाग है। इसमें हम एक टकराव में मोर्टार टावरों को अलग करने वाले गोले दागेंगे।

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

दुश्मनों पर बम बरसाए जाते हैं।

टावरों के प्रकार

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

सार टॉवर

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

 using UnityEngine; public abstract class Tower : GameTileContent { const int enemyLayerMask = 1 << 9; static Collider[] targetsBuffer = new Collider[100]; [SerializeField, Range(1.5f, 10.5f)] protected float targetingRange = 1.5f; protected bool AcquireTarget (out TargetPoint target) { … } protected bool TrackTarget (ref TargetPoint target) { … } void OnDrawGizmosSelected () { Gizmos.color = Color.yellow; Vector3 position = transform.localPosition; position.y += 0.01f; Gizmos.DrawWireSphere(position, targetingRange); } }

डुप्लिकेट क्लास को बदलें ताकि यह एक LaserTower में बदल जाए जो Tower विस्तार करता है और डुप्लिकेट कोड से छुटकारा पाने के लिए अपने बेस क्लास की कार्यक्षमता का उपयोग करता है।

 using UnityEngine; public class LaserTower : Tower { [SerializeField, Range(1f, 100f)] float damagePerSecond = 10f; [SerializeField] Transform turret = default, laserBeam = default; TargetPoint target; Vector3 laserBeamScale; void Awake () { laserBeamScale = laserBeam.localScale; } public override void GameUpdate () { if (TrackTarget(ref target) || AcquireTarget(out target)) { Shoot(); } else { laserBeam.localScale = Vector3.zero; } } void Shoot () { … } }

फिर नए घटक का उपयोग करने के लिए लेजर टॉवर के प्रीफैब को अपडेट करें।

एक लेजर टॉवर का घटक।

एक विशिष्ट प्रकार का टॉवर बनाना

चयन करने में सक्षम होने के लिए कि कौन से टावरों को मैदान पर रखा गया है, हम TowerType समान एक TowerType GameTileContentType । हम मौजूदा लेजर टॉवर और मोर्टार टॉवर के लिए समर्थन बनाएंगे, जिसे हम बाद में बनाएंगे।

 public enum TowerType { Laser, Mortar }

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

  public abstract TowerType TowerType€ { get; }

इसे LaserTower में फिर से परिभाषित करें ताकि यह सही प्रकार लौटाए।

  public override TowerType TowerType€ => TowerType.Laser;

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

  [SerializeField] Tower[] towerPrefabs = default; public GameTileContent Get (GameTileContentType type) { switch (type) { … } Debug.Assert(false, "Unsupported non-tower type: " + type); return null; } public GameTileContent Get (TowerType type) { Debug.Assert((int)type < towerPrefabs.Length, "Unsupported tower type!"); Tower prefab = towerPrefabs[(int)type]; Debug.Assert(type == prefab.TowerType€, "Tower prefab at wrong index!"); return Get(prefab); }

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

  public Tower Get (TowerType type) { … } T Get<T> (T prefab) where T : GameTileContent { T instance = CreateGameObjectInstance(prefab); instance.OriginFactory = this; return instance; }

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

प्रीफ़ैब टावरों की एक सरणी।

विशिष्ट टॉवर प्रकारों के उदाहरण बनाना

एक विशिष्ट प्रकार का टॉवर बनाने के लिए, हम GameBoard.ToggleTower ताकि इसे टॉवर टाइप पैरामीटर की आवश्यकता हो और इसे कारखाने में TowerType किया जा सके।

  public void ToggleTower (GameTile tile, TowerType towerType) { if (tile.Content.Type == GameTileContentType.Tower€) { … } else if (tile.Content.Type == GameTileContentType.Empty) { tile.Content = contentFactory.Get(towerType); … } else if (tile.Content.Type == GameTileContentType.Wall) { tile.Content = contentFactory.Get(towerType); updatingContent.Add(tile.Content); } }

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

  if (tile.Content.Type == GameTileContentType.Tower€) { updatingContent.Remove(tile.Content); if (((Tower)tile.Content).TowerType€ == towerType) { tile.Content = contentFactory.Get(GameTileContentType.Empty); FindPaths(); } else { tile.Content = contentFactory.Get(towerType); updatingContent.Add(tile.Content); } }

Game को अब स्विचेबल टॉवर के प्रकार को ट्रैक करना चाहिए। हम बस प्रत्येक प्रकार के टॉवर को एक संख्या से दर्शाते हैं। लेजर टॉवर 1 है, यह डिफ़ॉल्ट टॉवर होगा, और मोर्टार टॉवर 2 है। संख्या कुंजियों को दबाकर, हम उचित प्रकार के टॉवर का चयन करेंगे।

  TowerType selectedTowerType; … void Update () { … if (Input.GetKeyDown(KeyCode.G)) { board.ShowGrid = !board.ShowGrid; } if (Input.GetKeyDown(KeyCode.Alpha1)) { selectedTowerType = TowerType.Laser; } else if (Input.GetKeyDown(KeyCode.Alpha2)) { selectedTowerType = TowerType.Mortar; } … } … void HandleTouch () { GameTile tile = board.GetTile(TouchRay); if (tile != null) { if (Input.GetKey(KeyCode.LeftShift)) { board.ToggleTower(tile, selectedTowerType); } else { board.ToggleWall(tile); } } }

मोर्टार टॉवर

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

 using UnityEngine; public class MortarTower : Tower { [SerializeField, Range(0.5f, 2f)] float shotsPerSecond = 1f; [SerializeField] Transform mortar = default; public override TowerType TowerType€ => TowerType.Mortar; }

अब मोर्टार टॉवर के लिए एक प्रीफैब बनाएं। यह लेजर टॉवर के प्रीफैब को डुप्लिकेट करके और इसके टॉवर घटक को प्रतिस्थापित करके किया जा सकता है। फिर हम टॉवर और लेजर बीम की वस्तुओं से छुटकारा पा लेते हैं। turret को mortar नाम दें, इसे नीचे ले जाएं ताकि यह आधार के ऊपर खड़ा हो, इसे हल्के भूरे रंग का रंग दें और इसे संलग्न करें। हम मोर्टार कोलाइडर को छोड़ सकते हैं, इस मामले में, एक अलग वस्तु का उपयोग करते हुए, जो कि मोर्टार के डिफ़ॉल्ट अभिविन्यास पर आरोपित एक साधारण कोलाइडर है। मैंने 3.5 की मोर्टार रेंज और प्रति सेकंड 1 शॉट की आवृत्ति सौंपी।

मोर्टार टॉवर का प्रीफैब।

उन्हें मोर्टार क्यों कहा जाता है?

इस हथियार की पहली किस्में अनिवार्य रूप से लोहे के कटोरे थे, मोर्टार के समान, जिसमें सामग्री मूसल का उपयोग करके जमीन पर थी।

प्रीफ़ैब मोर्टार को फ़ैक्टरी सरणी में जोड़ें ताकि मोर्टार टावरों को मैदान पर रखा जा सके। हालांकि, वे अभी कुछ नहीं कर रहे हैं।

दो प्रकार के टॉवर, उनमें से एक निष्क्रिय

प्रक्षेपवक्र गणना

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

क्षैतिज लक्ष्य

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

MortarTower लिए एक MortarTower विधि जोड़ें, जो हमेशा Launch विधि को कॉल करता है। एक वास्तविक प्रक्षेप्य फायरिंग के बजाय, हम अभी के लिए गणितीय गणना की कल्पना करेंगे। फायरिंग पॉइंट दुनिया में मोर्टार की स्थिति है, जो जमीन के ठीक ऊपर स्थित है। हम एक्स अक्ष के साथ लक्ष्य तीन इकाइयों के बिंदु को रखते हैं, और वाई घटक को शून्य करते हैं, क्योंकि हम हमेशा जमीन पर निशाना लगाते हैं। तब हम उनके बीच Debug.DrawLine कॉल करके Debug.DrawLine पीले रंग की रेखा Debug.DrawLine अंक Debug.DrawLine । लाइन एक फ्रेम के लिए दृश्य मोड में दिखाई देगी, लेकिन यह पर्याप्त है, क्योंकि प्रत्येक फ्रेम में हम एक नई रेखा खींचते हैं।

  public override void GameUpdate () { Launch(); } public void Launch () { Vector3 launchPoint = mortar.position; Vector3 targetPoint = new Vector3(launchPoint.x + 3f, 0f, launchPoint.z); Debug.DrawLine(launchPoint, targetPoint, Color.yellow); }

हम टॉवर के सापेक्ष एक बिंदु पर लक्ष्य रखते हैं।

इस लाइन का उपयोग करके हम एक सही त्रिकोण को परिभाषित कर सकते हैं। उसका ऊपरी बिंदु मोर्टार स्थिति में है। मोर्टार के बारे में, यह है

$\ start {bmatrix} 0 \\ 0 \ end {bmatrix}$ । टॉवर के आधार पर नीचे का बिंदु है

$\ start {bmatrix} 0 \\ y \ end {bmatrix}$ , और लक्ष्य में बिंदु है

$\ start {bmatrix} x \\ y \ end {bmatrix}$ जहाँ

$x$ 3 के बराबर, और

$य$ मोर्टार की नकारात्मक ऊर्ध्वाधर स्थिति है। हमें इन दोनों मूल्यों को ट्रैक करने की आवश्यकता है।

  Vector3 launchPoint = mortar.position; Vector3 targetPoint = new Vector3(launchPoint.x + 3f, 0f, launchPoint.z); float x = 3f; float y = -launchPoint.y;

लक्ष्य साधना।

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

$\ start {bmatrix} 3 \\ 0 \ end {bmatrix}$ ।

$\ start {bmatrix} 0 \\ 1 \ end {bmatrix}$ ।

$\ start {bmatrix} 1 \\ 1 \ end {bmatrix}$ और

$\ start {bmatrix} 3 \\ 1 \ end {bmatrix}$ । जब लक्ष्य बिंदु शॉट के बिंदु के बराबर हो जाता है तो यह ऑफसेट हो जाता है, और फिर इसका Y समन्वय शून्य के बराबर हो जाता है।

  public override void GameUpdate () { Launch(new Vector3(3f, 0f, 0f)); Launch(new Vector3(0f, 0f, 1f)); Launch(new Vector3(1f, 0f, 1f)); Launch(new Vector3(3f, 0f, 1f)); } public void Launch (Vector3 offset) { Vector3 launchPoint = mortar.position; Vector3 targetPoint = launchPoint + offset; targetPoint.y = 0f; … }

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

  Vector2 dir; dir.x = targetPoint.x - launchPoint.x; dir.y = targetPoint.z - launchPoint.z; float x = dir.magnitude; float y = -launchPoint.y; dir /= x; Debug.DrawLine(launchPoint, targetPoint, Color.yellow); Debug.DrawLine( new Vector3(launchPoint.x, 0.01f, launchPoint.z), new Vector3( launchPoint.x + dir.x * x, 0.01f, launchPoint.z + dir.y * x ), Color.white );

संरेखित लक्ष्य त्रिकोण।

शॉट कोण

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

$वी$ और गुरुत्वाकर्षण

$g = 9.81$ ।

विस्थापन

$ड$ प्रक्षेप्य लक्ष्य त्रिकोण के अनुरूप है और इसे दो घटकों द्वारा वर्णित किया जा सकता है। क्षैतिज विस्थापन के साथ, यह सरल है: यह

$d_x = v_xt$ जहाँ

$टी$ - शॉट के बाद का समय। ऊर्ध्वाधर घटक के साथ सब कुछ समान है, फिर यह गुरुत्वाकर्षण के कारण नकारात्मक त्वरण के अधीन है, इसलिए इसका रूप है

$d_y = v_yt- (g t ^ 2) / 2$ ।

ऑफसेट गणना कैसे की जाती है?

गति

$वी$ दूरी प्रति सेकंड द्वारा निर्धारित किया जाता है, इसलिए, अवधि द्वारा गति को गुणा करना

$टी$ हमें दूरी मिलती है

$d = vt$ । जब त्वरण शामिल होता है

$एक$ , गति परिवर्तनशील है। त्वरण प्रति सेकंड गति में परिवर्तन है, अर्थात्, प्रति सेकंड की दूरी। किसी भी समय, गति है

$v = $ प$ । हमारे मामले में, निरंतर तेजी है

$a = -g$ , इसलिए हम इसे औसत गति प्राप्त करने के लिए आधे में विभाजित कर सकते हैं, और ऑफसेट को खोजने के लिए समय से गुणा कर सकते हैं

$d = (^ ^ 2) / 2$ गुरुत्वाकर्षण के कारण।

हमने उसी गति से गोले दागे

$एस$ जो शॉट के कोण पर निर्भर नहीं करता है

$$ थीटा$ (थीटा)। वह है

$v_x = s \ cos \ थीटा$ और

$v_y = s \ sin \ थीटा$ ।

शॉट गति की गणना।

स्थानापन्न प्रदर्शन, हम प्राप्त करते हैं

$d_x = st \ cos \ थीटा$ और

$d_y = st \ sin \ theta- (g t ^ 2) / 2$ ।

प्रक्षेप्य को निकाल दिया जाता है ताकि उसकी उड़ान का समय हो

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

$t = d_x / v_x$ । अंत बिंदु पर

$d_x = x$ वह है

$t = x / (s \ cos \ थीटा)$ । इसका मतलब है कि

$y = x \ tan \ थीटा- (gx ^ 2) / (2s ^ 2 \ cos ^ 2 \ ata)$ ।

समीकरण y कैसे प्राप्त करें?

$y = d_y = s (x / (s \ cos \ theta)) \ sin \ theta- (g (x / (s \ cos \ theta)) ^ 2) / 2 = x \ sin \ theta / \ cos \ थीटा- (gx ^ 2) / (2s ^ 2 \ cos ^ 2 \ थीटा)$ और

$\ tan \ थीटा = \ sin \ थीटा / \ cos \ थीटा$ ।

इस समीकरण का उपयोग हम पाते हैं

$\ tan \ थीटा = (s ^ 2 + - \ sqrt {s ^ 4-g (gx ^ 2 + 2ys ^ 2))}) / (gx)$ ।

समीकरण to कैसे प्राप्त करें?

पहले हम त्रिकोणमितीय पहचान का उपयोग करेंगे

$\ sec \ थीटा = 1 / \ cos \ थीटा$ और

$1 + \ tan ^ 2 \ थीटा = \ sec ^ 2 \ थीटा$ आने के लिए

$y = x \ tan \ theta- (gx ^ 2) / (2s ^ 2) (1+ \ tan ^ 2 \ theta) = - (gx ^ 2) / (2s ^ 2) \ tan ^ 2 \ theta + x \ tan \ theta- (gx ^ 2) / (2s ^ 2)$ ।

यह रूप की अभिव्यक्ति है

$औ ^ 2 + बू + सी = 0$ जहाँ

$u = \ tan \ थीटा$ ।

$a = - (gx ^ 2) / (2s ^ 2)$ ।

$b = x$ , और

$सी = ए-वाई$ ।

हम इसे द्विघात समीकरण की जड़ों के सूत्र का उपयोग करके हल कर सकते हैं

$u = (- b + - \ sqrt {(b ^ 2-4ac)}) / (2a)$ ।

इसके प्रतिस्थापन के बाद, समीकरण भ्रमित हो जाएगा, लेकिन आप इसे गुणा करके सरल कर सकते हैं

$m = s ^ 2 / x$ तो पाने के लिए

$\ tan \ theta = (- mb + -m \ sqrt {r}) / (2ma)$ जहाँ

$r = b ^ 2-4ac$ ।

इस मामले में, हम प्राप्त करते हैं

$\ tan \ थीटा = (s ^ 2 + - \ sqrt {(m ^ 2r)}) / (gx)$ ।

परिणामस्वरूप

$m ^ 2r = (s ^ 4 / x ^ 2) r = s ^ 4 + 2gs ^ 2c = s ^ 4-g ^ 2x ^ 2-2gys ^ 2 = s ^ 4-g (gx ^ 2 + 2ys ^ 2)$ ।

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

$\ tan \ थीटा = (s ^ 2 + \ sqrt {s ^ 4-g (gx ^ 2 + 2ys ^ 2))}) / (gx)$ । हम इसकी गणना करते हैं, और भी

$\ cos \ थीटा$ साथ

$\ sin \ थीटा$ , क्योंकि हम उन्हें शॉट के वेग वेक्टर प्राप्त करने की आवश्यकता है। इसके लिए आपको कन्वर्ट करने की आवश्यकता है

$\ tan \ थीटा$ Mathf.Atan का उपयोग कर रेडियन कोण पर। पहले, चलो 5 की एक निरंतर शॉट गति का उपयोग करें।

  float x = dir.magnitude; float y = -launchPoint.y; dir /= x; float g = 9.81f; float s = 5f; float s2 = s * s; float r = s2 * s2 - g * (g * x * x + 2f * y * s2); float tanTheta = (s2 + Mathf.Sqrt(r)) / (g * x); float cosTheta = Mathf.Cos(Mathf.Atan(tanTheta)); float sinTheta = cosTheta * tanTheta;

आइए उड़ान के पहले दूसरे भाग को दिखाते हुए दस नीले खंडों को चित्रित करके प्रक्षेपवक्र की कल्पना करें।

  float sinTheta = cosTheta * tanTheta; Vector3 prev = launchPoint, next; for (int i = 1; i <= 10; i++) { float t = i / 10f; float dx = s * cosTheta * t; float dy = s * sinTheta * t - 0.5f * g * t * t; next = launchPoint + new Vector3(dir.x * dx, dy, dir.y * dx); Debug.DrawLine(prev, next, Color.blue); prev = next; }

परबोला उड़ान के रास्ते एक सेकंड तक चलते हैं।

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

शॉट की गति

यदि आप एक सेकंड में निकटतम दो बिंदुओं तक पहुंचना चाहते हैं, तो आपको शॉट की गति को कम करने की आवश्यकता है। इसे 4 के बराबर बनाते हैं।

  float s = 4f;

शॉट स्पीड 4 से कम हो गई।

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

$\ tan \ थीटा$ नहीं, अर्थात, हम एक ऋणात्मक संख्या का वर्गमूल प्राप्त करते हैं, जिससे NaN मान और रेखाओं का लोप हो जाता है। हम इसे जाँच कर पहचान सकते हैं

$आर$ नकारात्मकता के लिए।

  float r = s2 * s2 - g * (g * x * x + 2f * y * s2); Debug.Assert(r >= 0f, "Launch velocity insufficient for range!");

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

अधिकतम सीमा पर

$r = 0$ , यानी के लिए

$\ tan \ थीटा$ केवल एक ही उपाय है जो निम्न पथ से मेल खाता है इसका मतलब है कि हम शॉट की आवश्यक गति जानते हैं।

$s = \ sqrt {(g (y + \ sqrt {(x ^ 2 + y ^ 2)})) 2$ ।

इस समीकरण को s के लिए कैसे प्राप्त करें?

तय करने की जरूरत है

$s ^ 4-g (gx ^ 2 + 2ys ^ 2) = s ^ 4-2gys ^ 2-g ^ 2x ^ 2 = 0$ के लिए

$एस$ ।

यह रूप की अभिव्यक्ति है

$औ ^ 2 + बू + सी = 0$ जहाँ

$u = s ^ 2$ ।

$a = 1$ ।

$b = -2gy$ और

$c = -g ^ 2x ^ 2$ ।

आप द्विघात समीकरण की जड़ों के सरलीकृत सूत्र का उपयोग करके इसे हल कर सकते हैं

$u = (- b + - \ sqrt {(b ^ 2-4c)}) / 2$ ।

प्रतिस्थापन के बाद हम प्राप्त करते हैं

$s ^ 2 = (2gy + - \ sqrt {(4g ^ 2y ^ 2 + 4g ^ 2x ^ 2)}) / 2 = gy + -g \ sqrt {(x ^ 2 + y ^ 2)}$ ।

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

$s ^ 2 = g (y + \ sqrt {(x ^ 2 + y ^ 2)})$ ।

हमें आवश्यक गति को केवल तभी निर्धारित करना होगा जब मोर्टर्स जागें (जागें) या जब हम प्ले मोड में इसकी रेंज बदलें। इसलिए, हम इसे फ़ील्ड का उपयोग करके ट्रैक करेंगे और इसे Awake और OnValidate में गणना करेंगे।

  float launchSpeed; void Awake () { OnValidate(); } void OnValidate () { float x = targetingRange; float y = -mortar.position.y; launchSpeed = Mathf.Sqrt(9.81f * (y + Mathf.Sqrt(x * x + y * y))); }

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

  float x = targetingRange + 0.25001f;

अगला, Launch में एक शॉट की गति के लिए व्युत्पन्न समीकरण लागू करें।

  float s = launchSpeed;

गणना की गई गति को लक्ष्य सीमा 3.5 पर लागू करें।

शूटिंग

प्रक्षेपवक्र की सही गणना होने से, आप सापेक्ष परीक्षण लक्ष्यों से छुटकारा पा सकते हैं। अब आपको Launch बिंदु को लक्ष्य के पास करने की आवश्यकता है।

  public void Launch (TargetPoint target) { Vector3 launchPoint = mortar.position; Vector3 targetPoint = target.Position; targetPoint.y = 0f; … }

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

  float launchProgress; … public override void GameUpdate () { launchProgress += shotsPerSecond * Time.deltaTime; while (launchProgress >= 1f) { if (AcquireTarget(out TargetPoint target)) { Launch(target); launchProgress -= 1f; } else { launchProgress = 0.999f; } } }

हम शॉट्स के बीच लक्ष्य को ट्रैक नहीं करते हैं, लेकिन हमें शॉट्स के दौरान मोर्टार को सही ढंग से घुमाने की जरूरत है। आप Quaternion.LookRotation का उपयोग करके क्षैतिज रूप से मोर्टार को घुमाने के लिए शॉट की क्षैतिज दिशा का उपयोग कर सकते हैं। हमें भी साथ चाहिए

$\ tan \ थीटा$ दिशा वेक्टर के घटक Y के लिए शॉट कोण लागू करें। यह काम करेगा क्योंकि क्षैतिज दिशा में 1 की लंबाई है, अर्थात।

$\ tan \ थीटा = \ sin \ थीटा$ ।

लुक के टर्न वेक्टर का अपघटन।

  float tanTheta = (s2 + Mathf.Sqrt(r)) / (g * x); float cosTheta = Mathf.Cos(Mathf.Atan(tanTheta)); float sinTheta = cosTheta * tanTheta; mortar.localRotation = Quaternion.LookRotation(new Vector3(dir.x, tanTheta, dir.y));

शॉट्स के प्रक्षेपवक्र को देखने के लिए, आप Debug.DrawLine को एक पैरामीटर जोड़ सकते हैं जो उन्हें लंबे समय तक Debug.DrawLine अनुमति देता है।

  Vector3 prev = launchPoint, next; for (int i = 1; i <= 10; i++) { … Debug.DrawLine(prev, next, Color.blue, 1f); prev = next; } Debug.DrawLine(launchPoint, targetPoint, Color.yellow, 1f); Debug.DrawLine( … Color.white, 1f );

उद्देश्य।

गोलाबारूद

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

युद्ध का कारखाना

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

 using UnityEngine; public abstract class WarEntity : MonoBehaviour { WarFactory originFactory; public WarFactory OriginFactory { get => originFactory; set { Debug.Assert(originFactory == null, "Redefined origin factory!"); originFactory = value; } } public void Recycle () { originFactory.Reclaim(this); } }

फिर Shellगोले के लिए एक विशिष्ट इकाई बनाएं ।

 using UnityEngine; public class Shell : WarEntity { }

फिर WarFactoryवह बनाएं जो सार्वजनिक गटर संपत्ति का उपयोग करके प्रक्षेप्य बनाएगा।

 using UnityEngine; [CreateAssetMenu] public class WarFactory : GameObjectFactory { [SerializeField] Shell shellPrefab = default; public Shell Shell€ => Get(shellPrefab); T Get<T> (T prefab) where T : WarEntity { T instance = CreateGameObjectInstance(prefab); instance.OriginFactory = this; return instance; } public void Reclaim (WarEntity entity) { Debug.Assert(entity.OriginFactory == this, "Wrong factory reclaimed!"); Destroy(entity.gameObject); } }

प्रोजेक्टाइल के लिए प्रीफ़ैब बनाएं। मैंने 0.25 और अंधेरे सामग्री के साथ-साथ एक घटक के साथ एक साधारण घन का उपयोग किया Shell। फिर फैक्टरी एसेट बनाएं और इसे प्रोजेक्टाइल के प्रीफैब को असाइन करें।

युद्ध का कारखाना।

खेल व्यवहार

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

 using UnityEngine; public abstract class GameBehavior : MonoBehaviour { public virtual bool GameUpdate () => true; }

अब पुनर्रचना प्रदर्शन EnemyCollection, में यह मोड़ GameBehaviorCollection।

 public class GameBehaviorCollection { List<GameBehavior> behaviors = new List<GameBehavior>(); public void Add (GameBehavior behavior) { behaviors.Add(behavior); } public void GameUpdate () { for (int i = 0; i < behaviors.Count; i++) { if (!behaviors[i].GameUpdate()) { int lastIndex = behaviors.Count - 1; behaviors[i] = behaviors[lastIndex]; behaviors.RemoveAt(lastIndex); i -= 1; } } } }

चलो इसका WarEntityविस्तार करते हैं GameBehavior, नहीं MonoBehavior।

 public abstract class WarEntity : GameBehavior { … }

हम Enemyइस बार विधि को ओवरराइड करने के लिए भी करेंगे GameUpdate।

 public class Enemy : GameBehavior { … public override bool GameUpdate () { … } … }

अब से, Gameइसे दो संग्रहों को ट्रैक करना होगा, एक दुश्मनों के लिए, दूसरा गैर-दुश्मनों के लिए। गैर-दुश्मनों को हर चीज के बाद अपडेट किया जाना चाहिए।

  GameBehaviorCollection enemies = new GameBehaviorCollection(); GameBehaviorCollection nonEnemies = new GameBehaviorCollection(); … void Update () { … enemies.GameUpdate(); Physics.SyncTransforms(); board.GameUpdate(); nonEnemies.GameUpdate(); }

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

  [SerializeField] WarFactory warFactory = default; … static Game instance; public static Shell SpawnShell () { Shell shell = instance.warFactory.Shell€; instance.nonEnemies.Add(shell); return shell; } void OnEnable () { instance = this; }

युद्ध कारखाने के साथ खेल।

क्या स्टैटिक फेशियल एक अच्छा उपाय है?

, , .

हम एक गोली मारते हैं

प्रक्षेप्य का एक उदाहरण बनाने के बाद, इसे अंतिम लक्ष्य तक पहुंचने तक अपने पथ के साथ उड़ना चाहिए। ऐसा करने के लिए, Shellविधि में जोड़ें Initializeऔर शॉट के बिंदु, लक्ष्य के बिंदु और शॉट की गति को निर्दिष्ट करने के लिए इसका उपयोग करें।

  Vector3 launchPoint, targetPoint, launchVelocity; public void Initialize ( Vector3 launchPoint, Vector3 targetPoint, Vector3 launchVelocity ) { this.launchPoint = launchPoint; this.targetPoint = targetPoint; this.launchVelocity = launchVelocity; }

अब हम एक शेल बना सकते हैं MortarTower.Launchऔर इसे सड़क पर भेज सकते हैं ।

  mortar.localRotation = Quaternion.LookRotation(new Vector3(dir.x, tanTheta, dir.y)); Game.SpawnShell().Initialize( launchPoint, targetPoint, new Vector3(s * cosTheta * dir.x, s * sinTheta, s * cosTheta * dir.y) );

प्रक्षेप्य गति

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

  float age; … public override bool GameUpdate () { age += Time.deltaTime; Vector3 p = launchPoint + launchVelocity * age; py -= 0.5f * 9.81f * age * age; transform.localPosition = p; return true; }

प्रोजेक्टाइल शूटिंग।

उनके प्रक्षेपवक्र के साथ गोले को संरेखित करने के लिए, हमें उन्हें व्युत्पन्न वेक्टर के साथ देखना होगा, जो कि इसी समय उनकी गति है।

  public override bool GameUpdate () { … Vector3 d = launchVelocity; dy -= 9.81f * age; transform.localRotation = Quaternion.LookRotation(d); return true; }

गोले मुड़ रहे हैं।

हम खेल को साफ करते हैं

अब जबकि यह स्पष्ट है कि गोले ठीक उसी तरह उड़ रहे हैं जैसे उन्हें चाहिए, तो आप MortarTower.Launchप्रक्षेपवक्र को दृश्य से हटा सकते हैं।

  public void Launch (TargetPoint target) { … Game.SpawnShell().Initialize( launchPoint, targetPoint, new Vector3(s * cosTheta * dir.x, s * sinTheta, s * cosTheta * dir.y) ); }

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

  public override bool GameUpdate () { age += Time.deltaTime; Vector3 p = launchPoint + launchVelocity * age; py -= 0.5f * 9.81f * age * age; if (py <= 0f) { OriginFactory.Reclaim(this); return false; } transform.localPosition = p; … }

विस्फोट

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

  [SerializeField, Range(0.5f, 3f)] float shellBlastRadius = 1f; [SerializeField, Range(1f, 100f)] float shellDamage = 10f;

विस्फोट त्रिज्या और 15 गोले के 1.5 क्षति।

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

  float age, blastRadius, damage; public void Initialize ( Vector3 launchPoint, Vector3 targetPoint, Vector3 launchVelocity, float blastRadius, float damage ) { … this.blastRadius = blastRadius; this.damage = damage; }

MortarTower इसके निर्माण के बाद केवल प्रक्षेप्य को डेटा संचारित करना चाहिए।

  Game.SpawnShell().Initialize( launchPoint, targetPoint, new Vector3(s * cosTheta * dir.x, s * sinTheta, s * cosTheta * dir.y), shellBlastRadius, shellDamage );

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

  const int enemyLayerMask = 1 << 9; static Collider[] buffer = new Collider[100]; public static int BufferedCount { get; private set; } public static bool FillBuffer (Vector3 position, float range) { Vector3 top = position; top.y += 3f; BufferedCount = Physics.OverlapCapsuleNonAlloc( position, top, range, buffer, enemyLayerMask ); return BufferedCount > 0; } public static TargetPoint GetBuffered (int index) { var target = buffer[index].GetComponent<TargetPoint>(); Debug.Assert(target != null, "Targeted non-enemy!", buffer[0]); return target; }

अब हम अधिकतम बफर आकार तक सीमा के भीतर सभी लक्ष्यों को प्राप्त कर सकते हैं और विस्फोट पर नुकसान पहुंचा सकते हैं Shell।

  if (py <= 0f) { TargetPoint.FillBuffer(targetPoint, blastRadius); for (int i = 0; i < TargetPoint.BufferedCount; i++) { TargetPoint.GetBuffered(i).Enemy€.ApplyDamage(damage); } OriginFactory.Reclaim(this); return false; }

गोले का विस्फोट।

आप TargetPointबफर से एक यादृच्छिक लक्ष्य प्राप्त करने के लिए एक स्थिर संपत्ति में भी जोड़ सकते हैं ।

  public static TargetPoint RandomBuffered => GetBuffered(Random.Range(0, BufferedCount));

यह हमें सरल बनाने की अनुमति देगा Tower, क्योंकि अब आप यादृच्छिक लक्ष्य की खोज के लिए उपयोग कर सकते हैं TargetPoint।

 protected bool AcquireTarget (out TargetPoint target) { if (TargetPoint.FillBuffer(transform.localPosition, targetingRange)) { target = TargetPoint.RandomBuffered; return true; } target = null; return false; }

विस्फोट

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

 using UnityEngine; public class Explosion : WarEntity { [SerializeField, Range(0f, 1f)] float duration = 0.5f; float age; public void Initialize (Vector3 position, float blastRadius, float damage) { TargetPoint.FillBuffer(position, blastRadius); for (int i = 0; i < TargetPoint.BufferedCount; i++) { TargetPoint.GetBuffered(i).Enemy.ApplyDamage(damage); } transform.localPosition = position; transform.localScale = Vector3.one * (2f * blastRadius); } public override bool GameUpdate () { age += Time.deltaTime; if (age >= duration) { OriginFactory.Reclaim(this); return false; } return true; } }

को एक विस्फोट जोड़ें WarFactory।

  [SerializeField] Explosion explosionPrefab = default; [SerializeField] Shell shellPrefab = default; public Explosion Explosion€ => Get(explosionPrefab); public Shell Shell => Get(shellPrefab);

एक विस्फोट के साथ युद्ध का कारखाना। मुखौटा विधि में

भी जोड़ें Game।

  public static Explosion SpawnExplosion () { Explosion explosion = instance.warFactory.Explosion€; instance.nonEnemies.Add(explosion); return explosion; }

अब यह Shellलक्ष्य तक पहुँचने पर विस्फोट उत्पन्न कर सकता है। विस्फोट से ही नुकसान होगा।

  if (py <= 0f) { Game.SpawnExplosion().Initialize(targetPoint, blastRadius, damage); OriginFactory.Reclaim(this); return false; }

गोले का धमाका।

चिकनी विस्फोट

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

  [SerializeField] AnimationCurve opacityCurve = default; [SerializeField] AnimationCurve scaleCurve = default;

अपारदर्शिता शून्य के साथ शुरू और समाप्त हो जाएगी, सुचारू रूप से 0.3 के औसत मूल्य तक पहुंच जाएगी। पैमाने 0.7 पर शुरू होगा, तेजी से बढ़ेगा, और फिर धीरे-धीरे 1 पर पहुंच जाएगा।

धमाका घटता है।

सामग्री का रंग निर्धारित करने के लिए, हम भौतिक गुणों के ब्लॉक का उपयोग करेंगे। जहाँ काला अपारदर्शिता चर है। पैमाना अब निर्धारित है GameUpdate, लेकिन हमें त्रिज्या क्षेत्र का उपयोग करके ट्रैक करने की आवश्यकता है। में Initialize, आप को दोगुना पैमाने का उपयोग कर सकते हैं। घटता का मान उन्हें Evaluateएक तर्क के साथ बुलाकर पाया जाता है, जिसे विस्फोट के वर्तमान जीवनकाल के रूप में गणना की जाती है, जिसे विस्फोट की अवधि से विभाजित किया जाता है।

  static int colorPropertyID = Shader.PropertyToID("_Color"); static MaterialPropertyBlock propertyBlock; … float scale; MeshRenderer meshRenderer; void Awake () { meshRenderer = GetComponent<MeshRenderer>(); Debug.Assert(meshRenderer != null, "Explosion without renderer!"); } public void Initialize (Vector3 position, float blastRadius, float damage) { … transform.localPosition = position; scale = 2f * blastRadius; } public override bool GameUpdate () { … if (propertyBlock == null) { propertyBlock = new MaterialPropertyBlock(); } float t = age / duration; Color c = Color.clear; ca = opacityCurve.Evaluate(t); propertyBlock.SetColor(colorPropertyID, c); meshRenderer.SetPropertyBlock(propertyBlock); transform.localScale = Vector3.one * (scale * scaleCurve.Evaluate(t)); return true; }

एनिमेटेड विस्फोट।

ट्रेसर के गोले

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

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

  public void Initialize ( Vector3 position, float blastRadius, float damage = 0f ) { if (damage > 0f) { TargetPoint.FillBuffer(position, blastRadius); for (int i = 0; i < TargetPoint.BufferedCount; i++) { TargetPoint.GetBuffered(i).Enemy.ApplyDamage(damage); } } transform.localPosition = position; radius = 2f * blastRadius; }

हम Shell.GameUpdateएक छोटे से त्रिज्या के साथ अंत में एक विस्फोट करेंगे , उदाहरण के लिए 0.1, उन्हें ट्रेसर के गोले में बदलना। यह ध्यान दिया जाना चाहिए कि इस दृष्टिकोण के साथ, विस्फोट फ्रेम द्वारा फ्रेम बनाया जाएगा, अर्थात, वे फ्रेम दर पर निर्भर करते हैं, लेकिन इस तरह के एक सरल प्रभाव के लिए यह स्वीकार्य है।

  public override bool GameUpdate () { … Game.SpawnExplosion().Initialize(p, 0.1f); return true; }

प्रक्षेप्य लक्षण।

ट्यूटोरियल रिपोजिटरी
पीडीएफ आलेख

एकता में टॉवर रक्षा बनाना: बैलिस्टिक्स

टावरों के प्रकार

सार टॉवर

एक विशिष्ट प्रकार का टॉवर बनाना

विशिष्ट टॉवर प्रकारों के उदाहरण बनाना

मोर्टार टॉवर

प्रक्षेपवक्र गणना

क्षैतिज लक्ष्य

शॉट कोण

शॉट की गति

शूटिंग

गोलाबारूद

युद्ध का कारखाना

खेल व्यवहार

हम एक गोली मारते हैं

प्रक्षेप्य गति

हम खेल को साफ करते हैं

विस्फोट

विस्फोट

चिकनी विस्फोट

ट्रेसर के गोले

More articles: