एकता में एक बिल्ली हुक बनाना। भाग 1

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

इस ट्यूटोरियल के पहले भाग में, हम अपनी दो आयामी हुक-कैट प्रणाली को लागू करते हैं और निम्नलिखित सीखते हैं:

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

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

काम पर लगना

इस ट्यूटोरियल के लिए ड्राफ्ट डाउनलोड करें और फिर इसे एकता संपादक में खोलें। ऑपरेशन के लिए एकता 2017.1 या उच्चतर आवश्यक है।

पर्दे के फ़ोल्डर से गेम का दृश्य खोलें और देखें कि हम कहां शुरू करेंगे:


अभी के लिए, हमारे पास एक साधारण खिलाड़ी चरित्र (स्लग) और पत्थर हवा में लटके हुए हैं।

GameObject Player के महत्वपूर्ण घटक कैप्सूल कोलाइडर और कठोरता हैं, जो इसे स्तर पर भौतिक वस्तुओं के साथ बातचीत करने की अनुमति देते हैं। इसके अलावा, एक साधारण मोशन स्क्रिप्ट ( PlayerMovement ) चरित्र से जुड़ी हुई है, जिससे यह जमीन पर फिसलने और सरल कूद करने की अनुमति देता है।

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


हमारे पास पहले से ही प्रबंधन की मूल बातें हैं, लेकिन अब सबसे बड़ी समस्या कैट हुक की कमी है।

हुक और रस्सी बनाना

सबसे पहले, बिल्ली-हुक प्रणाली काफी सरल लगती है, लेकिन इसके उच्च गुणवत्ता वाले कार्यान्वयन के लिए कई पहलुओं को ध्यान में रखना आवश्यक है। यहाँ दो-आयामी बिल्ली-हुक यांत्रिकी के लिए कुछ आवश्यकताएँ हैं:

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

पदानुक्रम में प्लेयर ऑब्जेक्ट का चयन करें और इसमें एक नया बच्चा GameObject जोड़ें RopeHingeAnchor नाम। इस GameObject का उपयोग कैट हुक के निलंबन / लंगर बिंदु को स्थिति में लाने के लिए किया जाएगा।

RopeHingeAnchor पर SpriteRenderer और RigidBody2D घटक जोड़ें।

SpriteRenderer के लिए, UISprite मान का उपयोग करने के लिए स्प्राइट प्रॉपर्टी सेट करें और ऑर्डर को लेयर में 2 में बदलें। इसके नाम के आगे बॉक्स को अनचेक करके घटक को अक्षम करें।

RigidBody2D घटक के लिए , बॉडी टाइप प्रॉपर्टी को काइनेटिक पर सेट करें। इस बिंदु को भौतिक इंजन द्वारा नहीं, बल्कि कोड द्वारा स्थानांतरित किया जाएगा।

रोप लेयर का चयन करें और ट्रांसफॉर्म कंपोनेंट के X और Y स्केल मान को 4 पर सेट करें ।


फिर से खिलाड़ी का चयन करें और नए DistanceJoint2D घटक को संलग्न करें।

RemoteJoint2D घटक की कनेक्टेड कठोर बॉडी प्रॉपर्टी पर पदानुक्रम से RopeHingeAnchor को खींचें और Auto Configure दूरी को बंद करें।


स्क्रिप्ट प्रोजेक्ट फ़ोल्डर में रोपसिस्टम नामक एक नया C # स्क्रिप्ट बनाएं और इसे कोड संपादक में खोलें।

Update विधि निकालें।

RopeSystem वर्ग RopeSystem अंदर स्क्रिप्ट के शीर्ष पर RopeSystem नए चर, Awake() विधि और नया Update :

 // 1 public GameObject ropeHingeAnchor; public DistanceJoint2D ropeJoint; public Transform crosshair; public SpriteRenderer crosshairSprite; public PlayerMovement playerMovement; private bool ropeAttached; private Vector2 playerPosition; private Rigidbody2D ropeHingeAnchorRb; private SpriteRenderer ropeHingeAnchorSprite; void Awake() { // 2 ropeJoint.enabled = false; playerPosition = transform.position; ropeHingeAnchorRb = ropeHingeAnchor.GetComponent<Rigidbody2D>(); ropeHingeAnchorSprite = ropeHingeAnchor.GetComponent<SpriteRenderer>(); } void Update() { // 3 var worldMousePosition = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0f)); var facingDirection = worldMousePosition - transform.position; var aimAngle = Mathf.Atan2(facingDirection.y, facingDirection.x); if (aimAngle < 0f) { aimAngle = Mathf.PI * 2 + aimAngle; } // 4 var aimDirection = Quaternion.Euler(0, 0, aimAngle * Mathf.Rad2Deg) * Vector2.right; // 5 playerPosition = transform.position; // 6 if (!ropeAttached) { } else { } } 

आइए प्रत्येक भाग का क्रम में विश्लेषण करें:

1. हम इन चरों का उपयोग उन विभिन्न घटकों को ट्रैक करने के लिए करते हैं जो रोपसिस्टम स्क्रिप्ट के साथ बातचीत करेंगे।
2. Awake विधि खेल की शुरुआत में शुरू होती है और ropeJoint ( ropeJoint घटक) को निष्क्रिय ropeJoint । यह playerPosition को प्लेयर की वर्तमान स्थिति में भी सेट करता है।
3. यह मुख्य Update() लूप का सबसे महत्वपूर्ण हिस्सा है। सबसे पहले, हम ScreenToWorldPoint कैमरा ScreenToWorldPoint का उपयोग करके दुनिया में माउस कर्सर की स्थिति प्राप्त करते हैं। फिर हम दुनिया में माउस की स्थिति से खिलाड़ी की स्थिति को घटाकर अपने टकटकी की दिशा की गणना करते हैं। तब हम इसका उपयोग लक्ष्य बनाने के लिए aimAngle , जो कर्सर के लक्ष्य कोण का प्रतिनिधित्व करता है। मान अगर निर्माण में एक सकारात्मक मूल्य संग्रहीत करता है।
4. aimDirection एक मोड़ है जो बाद में काम आता है। हम केवल Z मान में रुचि रखते हैं, क्योंकि हम एक 2D कैमरा का उपयोग कर रहे हैं, और यह एकमात्र संगत OS है। हम उद्देश्य पास aimAngle * Mathf.Rad2Deg , जो रेडियन कोण को डिग्री में कोण में परिवर्तित करता है।
5. खिलाड़ी की स्थिति को एक सुविधाजनक चर का उपयोग करके मॉनिटर किया जाता है, जिससे आप लगातार transform.Position उल्लेख नहीं कर सकते।
6. अंत में, हमारे पास if..else कंस्ट्रक्शन है, जिसका उपयोग हम जल्द ही यह निर्धारित करने के लिए करेंगे कि रस्सी एंकर पॉइंट से जुड़ी है या नहीं।

स्क्रिप्ट को सहेजें और संपादक पर वापस लौटें।

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

• रोप हिंज एंकर : रोपहिंग एंकर
• रस्सी संयुक्त : खिलाड़ी
• क्रॉसहेयर : क्रॉसहेयर
• क्रॉसहेयर स्प्राइट : क्रॉसहेयर
• प्लेयर मूवमेंट : प्लेयर

अब हम इन सभी जटिल गणनाओं को कर रहे हैं, लेकिन अभी तक ऐसा कोई दृश्य नहीं है जो उन्हें कार्रवाई में दिखा सके। लेकिन चिंता मत करो, हम इसे जल्द ही करेंगे।

रस्सीसिस्टम स्क्रिप्ट खोलें और इसमें एक नई विधि जोड़ें:

 private void SetCrosshairPosition(float aimAngle) { if (!crosshairSprite.enabled) { crosshairSprite.enabled = true; } var x = transform.position.x + 1f * Mathf.Cos(aimAngle); var y = transform.position.y + 1f * Mathf.Sin(aimAngle); var crossHairPosition = new Vector3(x, y, 0); crosshair.transform.position = crossHairPosition; } 

यह विधि संचारित aimAngle (फ्लोट मान जिसे हमने Update() में गणना की है Update() आधार पर दृष्टि को तैनात करता है ताकि यह खिलाड़ी के चारों ओर 1 यूनिट के त्रिज्या के साथ घूमता रहे। हम पहले से ही ऐसा नहीं होने की स्थिति में स्प्राइट स्कोप भी शामिल करते हैं।

Update() हम !ropeAttached कंस्ट्रक्शन को चेक करने के लिए !ropeAttached ताकि यह इस तरह !ropeAttached :

 if (!ropeAttached) { SetCrosshairPosition(aimAngle); } else { crosshairSprite.enabled = false; } 

स्क्रिप्ट को बचाएं और खेल को चलाएं। अब हमारे स्लग को एक दृष्टि से निशाना बनाने में सक्षम होना चाहिए।


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

RopeSystem स्क्रिप्ट में चर के नीचे निम्नलिखित चर जोड़ें:

 public LineRenderer ropeRenderer; public LayerMask ropeLayerMask; private float ropeMaxCastDistance = 20f; private List<Vector2> ropePositions = new List<Vector2>(); 

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

अंत में, वेक्टर 2 के पदों की सूची का उपयोग रस्सी लपेटने वाले बिंदुओं को ट्रैक करने के लिए किया जाएगा, जिसे हम बाद में चर्चा करेंगे।

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

 // 1 private void HandleInput(Vector2 aimDirection) { if (Input.GetMouseButton(0)) { // 2 if (ropeAttached) return; ropeRenderer.enabled = true; var hit = Physics2D.Raycast(playerPosition, aimDirection, ropeMaxCastDistance, ropeLayerMask); // 3 if (hit.collider != null) { ropeAttached = true; if (!ropePositions.Contains(hit.point)) { // 4 //    ,    -  . transform.GetComponent<Rigidbody2D>().AddForce(new Vector2(0f, 2f), ForceMode2D.Impulse); ropePositions.Add(hit.point); ropeJoint.distance = Vector2.Distance(playerPosition, hit.point); ropeJoint.enabled = true; ropeHingeAnchorSprite.enabled = true; } } // 5 else { ropeRenderer.enabled = false; ropeAttached = false; ropeJoint.enabled = false; } } if (Input.GetMouseButton(1)) { ResetRope(); } } // 6 private void ResetRope() { ropeJoint.enabled = false; ropeAttached = false; playerMovement.isSwinging = false; ropeRenderer.positionCount = 2; ropeRenderer.SetPosition(0, transform.position); ropeRenderer.SetPosition(1, transform.position); ropePositions.Clear(); ropeHingeAnchorSprite.enabled = false; } 

यहाँ उपरोक्त कोड क्या है:

1. HandleInput को Update() लूप से पुकारा जाता है और बस बाएं और दाएं माउस बटन के इनपुट को पोल करता है।
2. जब एक बायाँ-क्लिक पंजीकृत होता है, तो रस्सी रेखा चालू हो जाती है और एक 2D- रेकास्ट को लक्ष्य की दिशा में खिलाड़ी की स्थिति से निकाल दिया जाता है। अधिकतम दूरी निर्धारित की जाती है ताकि हुक बिल्ली को एक अनंत दूरी पर गोली न मारी जा सके, और एक मुखौटा लगाया जाता है ताकि भौतिकी की परतों का चयन करना संभव हो, जिसमें रेकास्ट टकरा सकता है।
3. यदि एक रेकास्ट हिट का पता चला है, तो ropeAttached true , और यह सुनिश्चित करने के लिए रस्सी के कोने के पदों की एक सूची की जांच की जाती है कि वहां कोई बिंदु नहीं है।
4. यदि परीक्षण सही हो जाता है, तो बल के एक छोटे से आवेग को स्लग में जोड़ा जाता है ताकि यह जमीन से ऊपर ropeJoint , ropeJoint ( ropeJoint ) को चालू ropeJoint , जो स्लग और रेयास्ट हिट बिंदु के बीच की दूरी के बराबर दूरी पर सेट होता है। लंगर बिंदु स्प्राइट भी शामिल है।
5. यदि रेकास्ट कुछ भी हिट नहीं करता है, तो लाइन रेंडरर और रस्सीजॉइंट अक्षम हो जाते हैं, और ropeAttached ध्वज झूठा है।
6. यदि सही माउस बटन दबाया जाता है, तो ResetRope() विधि को ResetRope() , जो रस्सी / हुक से संबंधित सभी मापदंडों को निष्क्रिय करता है और उन मानों को रीसेट करता है जो हुक का उपयोग नहीं किया जाना चाहिए।

हमारे Update विधि के सबसे निचले भाग में, नए HandleInput() विधि में एक कॉल जोड़ें और इसके लिए aimDirection पास करें:

 HandleInput(aimDirection); 

RopeSystem.cs में परिवर्तन सहेजें और संपादक पर लौटें।

रस्सी जोड़ना

हमारा स्लग रस्सी के बिना हवा के माध्यम से उड़ान भरने में सक्षम नहीं होगा, इसलिए इसे कुछ ऐसा देने का समय है जो रस्सी का एक दृश्य प्रतिनिधित्व होगा और इसमें कोनों के चारों ओर "मोड़" करने की क्षमता है।

लाइन रेंडरर इसके लिए आदर्श है, क्योंकि यह हमें दुनिया की जगह में अंकों की संख्या और उनकी स्थिति को स्थानांतरित करने की अनुमति देता है।

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

प्लेयर का चयन करें और इसमें LineRenderer घटक जोड़ें। चौड़ाई को 0.075 पर सेट करें। सामग्री सूची का विस्तार करें और, तत्व 0 के रूप में, प्रोजेक्ट के सामग्री फ़ोल्डर में स्थित रोपमैट सामग्री का चयन करें। आखिर में लाइन रेंडरर के लिए, टेक्सचर मोड के लिए, डिस्ट्रीब्यूट प्रति सेगमेंट चुनें ।


रोप सिस्टम घटक के रोप रेंडरर क्षेत्र में लाइन रेंडरर घटक को खींचें।

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


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


हमने अभी तक संयुक्त दूरी के लिए दूरी निर्धारित नहीं की है, इसके अलावा, लाइन रेंडर के कोने कॉन्फ़िगर नहीं किए गए हैं। इसलिए, हम रस्सी को नहीं देखते हैं, और चूंकि दूरी संयुक्त सीधे स्लग की स्थिति से ऊपर है, दूरी संयुक्त दूरी का वर्तमान मूल्य इसे नीचे के पत्थरों तक पहुंचाता है।

लेकिन चिंता मत करो, अब हम इस समस्या को हल करेंगे।

RopeSystem.cs स्क्रिप्ट में , क्लास की शुरुआत में एक नया ऑपरेटर जोड़ें:

 using System.Linq; 

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

नोट : भाषा-एकीकृत क्वेरी (LINQ) प्रौद्योगिकियों का एक सेट का नाम है जो सीधे सी # में क्वेरी क्षमताओं को एम्बेड करने पर आधारित है। आप इसके बारे में और अधिक यहाँ पढ़ सकते हैं।

अन्य चर के अंतर्गत distanceSet के नाम से एक नया बूल निजी चर जोड़ें:

 private bool distanceSet; 

हम इस चर को एक ध्वज के रूप में उपयोग करेंगे ताकि स्क्रिप्ट यह पहचान सके कि रस्सी की दूरी (खिलाड़ी और वर्तमान संदर्भ बिंदु के बीच जहां कैट हुक संलग्न है) सही ढंग से सेट है।

अब एक नई विधि जोड़ें जिसका उपयोग हम लाइन को रेंडर करने के लिए रस्सी की स्थिति के पदों को सेट करने के लिए करेंगे और रस्सी ( ropePositions ) के साथ पदों की संग्रहीत सूची में दूरी की संयुक्त दूरी निर्धारित ropePositions :

 private void UpdateRopePositions() { // 1 if (!ropeAttached) { return; } // 2 ropeRenderer.positionCount = ropePositions.Count + 1; // 3 for (var i = ropeRenderer.positionCount - 1; i >= 0; i--) { if (i != ropeRenderer.positionCount - 1) // if not the Last point of line renderer { ropeRenderer.SetPosition(i, ropePositions[i]); // 4 if (i == ropePositions.Count - 1 || ropePositions.Count == 1) { var ropePosition = ropePositions[ropePositions.Count - 1]; if (ropePositions.Count == 1) { ropeHingeAnchorRb.transform.position = ropePosition; if (!distanceSet) { ropeJoint.distance = Vector2.Distance(transform.position, ropePosition); distanceSet = true; } } else { ropeHingeAnchorRb.transform.position = ropePosition; if (!distanceSet) { ropeJoint.distance = Vector2.Distance(transform.position, ropePosition); distanceSet = true; } } } // 5 else if (i - 1 == ropePositions.IndexOf(ropePositions.Last())) { var ropePosition = ropePositions.Last(); ropeHingeAnchorRb.transform.position = ropePosition; if (!distanceSet) { ropeJoint.distance = Vector2.Distance(transform.position, ropePosition); distanceSet = true; } } } else { // 6 ropeRenderer.SetPosition(i, transform.position); } } } 

ऊपर दिखाया गया कोड बताएं:

1. रस्सी संलग्न न होने पर विधि से बाहर निकलें।
2. हम रोप लाइन के रेंडर पॉइंट्स की वैल्यू असाइन करते हैं जो रोप पोजिशन में स्टोर किए गए ropePositions की संख्या से अधिक 1 (प्लेयर की पोजीशन के लिए) है।
3. हम प्रत्येक स्थिति (अंतिम को छोड़कर) के लिए ropePositions सूची और लूप के चारों ओर लूप करते हैं, ropePositions सूची में लूप इंडेक्स द्वारा संग्रहीत ropePositions स्थिति के मान को लाइन रेंडरर के शीर्ष की स्थिति प्रदान करते हैं।
4. रस्सी के अंत बिंदु से दूसरी जगह रस्सी के लंगर बिंदु को असाइन करें, जिसमें वर्तमान काज / लंगर बिंदु होना चाहिए, या यदि हमारे पास रस्सी की केवल एक स्थिति है, तो इसे लंगर बिंदु बनाएं। तो हम दूरी ropeJoint सेट करते हैं। खिलाड़ी के बीच की दूरी और रस्सी की वर्तमान स्थिति के बीच की दूरी, जो हम लूप में ropeJoint ।
5. यदि निर्माण उस मामले को संभालता है जहां लूप में रस्सी की वर्तमान स्थिति अंत से दूसरी है; यानी वह बिंदु जिस पर रस्सी वस्तु से जुड़ती है, अर्थात्। वर्तमान काज / लंगर बिंदु।
6. यह else ब्लॉक खिलाड़ी की वर्तमान स्थिति के मान को रस्सी के अंतिम शीर्ष की स्थिति के असाइनमेंट को संभालता है।

UpdateRopePositions() कॉल को Update() के अंत में जोड़ना याद रखें UpdateRopePositions() :

 UpdateRopePositions(); 

स्क्रिप्ट में परिवर्तन सहेजें और खेल को फिर से चलाएँ। लक्ष्य से ऊपर एक पत्थर पर एक हुक के साथ निशाना लगाकर और शूटिंग करके एक "छोटी जगह" को एक छोटी छलांग बनाएं। अब आप अपने मजदूरों के फलों का आनंद ले सकते हैं - पत्थरों पर शांत तरीके से ढलान।


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

लपेटने के अंक को संभालना

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


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

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

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

ऐसा लगता है कि यह अच्छी पुरानी रेकास्ट के लिए फिर से काम है!


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

RopeSystem.cs स्क्रिप्ट में एक नई विधि जोड़ें:

 // 1 private Vector2 GetClosestColliderPointFromRaycastHit(RaycastHit2D hit, PolygonCollider2D polyCollider) { // 2 var distanceDictionary = polyCollider.points.ToDictionary<Vector2, float, Vector2>( position => Vector2.Distance(hit.point, polyCollider.transform.TransformPoint(position)), position => polyCollider.transform.TransformPoint(position)); // 3 var orderedDictionary = distanceDictionary.OrderBy(e => e.Key); return orderedDictionary.Any() ? orderedDictionary.First().Value : Vector2.zero; } 

यदि आप LINQ प्रश्नों से परिचित नहीं हैं, तो यह कोड किसी प्रकार के जटिल C # जादू की तरह लग सकता है।


यदि ऐसा है, तो डरें नहीं। LINQ हमारे लिए बहुत काम करता है:

1. यह विधि दो पैरामीटर लेती है - RaycastHit2D ऑब्जेक्ट और PolygonCollider2D ऑब्जेक्ट । स्तर पर सभी पत्थरों में PolygonCollider2D कोलाइडर होते हैं, इसलिए यदि हम हमेशा PolygonCollider2D आकृतियों का उपयोग करते हैं, तो यह ठीक काम करेगा।
2. यह वह जगह है जहाँ LINQ क्वेरी मैजिक शुरू होता है! यहां हम पॉलीगॉनल कोलाइडर के बिंदुओं के संग्रह को वेक्टर 2 (शब्दकोश के प्रत्येक तत्व का मूल्य स्वयं स्थिति है) के एक शब्दकोश में बदलते हैं, और प्रत्येक तत्व की कुंजी को इस बिंदु से खिलाड़ी के स्थिति खिलाड़ी (फ्लोट मान) की दूरी के लिए असाइन किया गया है। कभी-कभी यहां कुछ और होता है: परिणामी स्थिति को विश्व स्थान में बदल दिया जाता है (डिफ़ॉल्ट रूप से, कोलाइडर के पदों को स्थानीय अंतरिक्ष में संग्रहीत किया जाता है, अर्थात्, उस वस्तु के सापेक्ष स्थानीय संबंध जिससे कोलाइडर संबंधित है, और हमें विश्व स्थान में पदों की आवश्यकता है)।
3. शब्दकोश कुंजी द्वारा सॉर्ट किया गया है। दूसरे शब्दों में, खिलाड़ी की वर्तमान स्थिति के निकटतम दूरी से। निकटतम दूरी वापस आ गई है, अर्थात, इस विधि द्वारा लौटाया गया कोई भी बिंदु खिलाड़ी और रस्सी के काज के बीच का बिंदु है!

आइए वापस रोपसिस्टम स्क्रिप्ट पर जाएं और शीर्ष पर एक नया निजी क्षेत्र चर जोड़ें:

 private Dictionary<Vector2, int> wrapPointsLookup = new Dictionary<Vector2, int>(); 

हम इसका उपयोग उन पदों को ट्रैक करने के लिए करेंगे जिनके चारों ओर रस्सी लपेट सकती है।

Update() विधि के अंत में, वही निर्माण ढूंढें जिसमें crosshairSprite.enabled = false; और निम्नलिखित जोड़ें:

 // 1 if (ropePositions.Count > 0) { // 2 var lastRopePoint = ropePositions.Last(); var playerToCurrentNextHit = Physics2D.Raycast(playerPosition, (lastRopePoint - playerPosition).normalized, Vector2.Distance(playerPosition, lastRopePoint) - 0.1f, ropeLayerMask); // 3 if (playerToCurrentNextHit) { var colliderWithVertices = playerToCurrentNextHit.collider as PolygonCollider2D; if (colliderWithVertices != null) { var closestPointToHit = GetClosestColliderPointFromRaycastHit(playerToCurrentNextHit, colliderWithVertices); // 4 if (wrapPointsLookup.ContainsKey(closestPointToHit)) { ResetRope(); return; } // 5 ropePositions.Add(closestPointToHit); wrapPointsLookup.Add(closestPointToHit, 0); distanceSet = false; } } } 

इस कोड को समझाइए:

1. यदि कुछ पदों को ropePositions सूची में संग्रहीत किया जाता है, तो ...
2. हम सूची से रस्सी की अंतिम स्थिति को देखने वाले खिलाड़ी की दिशा में खिलाड़ी की स्थिति से शूट करते हैं - संदर्भ बिंदु जिस पर बिल्ली ने पत्थर को झुका दिया - खिलाड़ी के बीच की दूरी के बराबर रेकास्ट की दूरी और रस्सी के संदर्भ बिंदु की स्थिति।
3. यदि रेकास्ट कुछ के साथ टकराता है, तो इस ऑब्जेक्ट के कोलाइडर को सुरक्षित रूप से पॉलीगोनकॉलिडर 2 डी प्रकार में डाला जाता है। हालांकि यह एक सच्चा PolygonCollider2D है, इस कोलाइडर की निकटतम शीर्ष स्थिति को हम वेक्टर 2 के पहले लिखे गए तरीके का उपयोग करके लौटाते हैं।
4. यह सुनिश्चित करने के लिए कि उसी स्थिति को फिर से जाँच नहीं किया जाता है, इसे wrapPointsLookup द्वारा चेक किया जाता है। यदि यह जाँच की जाती है, तो हम रस्सी को छोड़ देते हैं और इसे काट देते हैं, खिलाड़ी को गिरा देते हैं।
5. फिर ropePositions सूची ropePositions : उस स्थिति को जोड़ा जाता है जिसके चारों ओर रस्सी ropePositions चाहिए। wrapPointsLookup शब्दकोश भी अपडेट किया गया है। अंत में, UpdateRopePositions() फ्लैग को रीसेट किया जाता है ताकि UpdateRopePositions() विधि रस्सी की लंबाई और सेगमेंट के साथ रस्सी की दूरी को फिर से परिभाषित कर सके।

ResetRope() निम्न पंक्ति जोड़ें ResetRope() ताकि एक खिलाड़ी द्वारा एक रस्सी को काट देने पर हर बार wrapPointsLookup डिक्शनरी साफ़ हो जाए:

 wrapPointsLookup.Clear(); 

गेम को सहेजें और लॉन्च करें। स्लग के ऊपर पत्थर के हुक में बिल्ली के हुक को गोली मारो और कई पत्थर के किनारों पर स्लग को स्थानांतरित करने के लिए दृश्य विंडो में मूव टूल का उपयोग करें।


यही कारण है कि हमने वस्तुओं को लपेटने के लिए रस्सी सिखाई!

रॉकिंग क्षमता जोड़ें

रस्सी पर लटका हुआ स्लग बहुत स्थिर है। इसे ठीक करने के लिए, हम स्विंगिंग की क्षमता को जोड़ सकते हैं।

ऐसा करने के लिए, हमें आगे की तरफ (बग़ल में) झूलने की स्थिति के लिए एक स्थिति प्राप्त करने की आवश्यकता है, चाहे जिस कोण से वह देख रहा हो।

PlayerMovement.cs खोलें और स्क्रिप्ट के शीर्ष पर निम्नलिखित दो सार्वजनिक चर जोड़ें:

 public Vector2 ropeHook; public float swingForce = 4f; 

ropeHook वेरिएबल को किसी भी स्थिति में सौंपा जाएगा जिसमें रोप हुक वर्तमान में स्थित है, और swingForce वह मूल्य है जो हम स्विंग मोशन को जोड़ने के लिए उपयोग करते हैं।

FixedUpdate() विधि FixedUpdate() नए के FixedUpdate() बदलें:

 void FixedUpdate() { if (horizontalInput < 0f || horizontalInput > 0f) { animator.SetFloat("Speed", Mathf.Abs(horizontalInput)); playerSprite.flipX = horizontalInput < 0f; if (isSwinging) { animator.SetBool("IsSwinging", true); // 1 -          var playerToHookDirection = (ropeHook - (Vector2)transform.position).normalized; // 2 -  ,     Vector2 perpendicularDirection; if (horizontalInput < 0) { perpendicularDirection = new Vector2(-playerToHookDirection.y, playerToHookDirection.x); var leftPerpPos = (Vector2)transform.position - perpendicularDirection * -2f; Debug.DrawLine(transform.position, leftPerpPos, Color.green, 0f); } else { perpendicularDirection = new Vector2(playerToHookDirection.y, -playerToHookDirection.x); var rightPerpPos = (Vector2)transform.position + perpendicularDirection * 2f; Debug.DrawLine(transform.position, rightPerpPos, Color.green, 0f); } var force = perpendicularDirection * swingForce; rBody.AddForce(force, ForceMode2D.Force); } else { animator.SetBool("IsSwinging", false); if (groundCheck) { var groundForce = speed * 2f; rBody.AddForce(new Vector2((horizontalInput * groundForce - rBody.velocity.x) * groundForce, 0)); rBody.velocity = new Vector2(rBody.velocity.x, rBody.velocity.y); } } } else { animator.SetBool("IsSwinging", false); animator.SetFloat("Speed", 0f); } if (!isSwinging) { if (!groundCheck) return; isJumping = jumpInput > 0f; if (isJumping) { rBody.velocity = new Vector2(rBody.velocity.x, jumpSpeed); } } } 

यहां मुख्य बदलाव यह है कि झंडे को पहले चेक किया जाता है isSwingingताकि कार्रवाई केवल तब की जाए जब स्लग को रस्सी पर लटका दिया जाए, और हम स्लग के कोने पर एक लंबवत जोड़ते हैं, यह रस्सी के शीर्ष पर इसके वर्तमान एंकर बिंदु को दर्शाता है, लेकिन इसकी स्विंग की दिशा के लिए लंबवत।

1. हम खिलाड़ी से हुक लगाव बिंदु तक सामान्यीकृत दिशा वेक्टर प्राप्त करते हैं।
2. इस बात पर निर्भर करता है कि स्लग साइड लेफ्ट है या राइट, सीधा दिशा की गणना की जाती है playerToHookDirection। डिबग ड्रा कॉल भी जोड़ा गया है ताकि आप चाहें तो इसे संपादक में देख सकें।

RopeSystem.cs खोलें और विधि के अंदर अन्य ब्लॉक के शीर्ष पर निम्नलिखित जोड़ें:if(!ropeAttached)Update()

 playerMovement.isSwinging = true; playerMovement.ropeHook = ropePositions.Last(); 

में अगर ब्लॉक एक ही डिजाइन की if(!ropeAttached), निम्नलिखित जोड़ें:

 playerMovement.isSwinging = false; 

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

यदि आप एक चल रहे खेल में गिज़्मो को चालू करते हैं और बाएं या दाएं स्विंग करने के लिए ए या डी दबाते हैं तो यह कैसा दिखता है:

रस्सी वंश जोड़ना

जबकि हमारे पास रस्सी को ऊपर और नीचे ले जाने की क्षमता नहीं है। हालांकि वास्तविक जीवन में स्लग आसानी से रस्सी के साथ नहीं उठ सकता और गिर सकता है, लेकिन यह एक ऐसा खेल है जिसमें कुछ भी हो सकता है, है ना? रस्सीसिस्टम

स्क्रिप्ट के शीर्ष पर , दो नए फ़ील्ड चर जोड़ें:

 public float climbSpeed = 3f; private bool isColliding; 

climbSpeedउस गति को निर्धारित करेगा जिस पर स्लग ऊपर और नीचे रस्सी को isCollidingले जा सकती है , और यह निर्धारित करने के लिए एक ध्वज के रूप में उपयोग किया जाएगा कि दूरी संयुक्त रस्सी की दूरी संयुक्त संपत्ति को बढ़ाया या घटाया जा सकता है।

इस नई विधि को जोड़ें:

 private void HandleRopeLength() { // 1 if (Input.GetAxis("Vertical") >= 1f && ropeAttached && !isColliding) { ropeJoint.distance -= Time.deltaTime * climbSpeed; } else if (Input.GetAxis("Vertical") < 0f && ropeAttached) { ropeJoint.distance += Time.deltaTime * climbSpeed; } } 

यह ब्लॉक if..elseifऊर्ध्वाधर अक्ष के साथ इनपुट को पढ़ता है (कीबोर्ड पर / नीचे या डब्ल्यू / एस), और, झंडे को ध्यान में रखते हुए, ropeAttached iscCollidingदूरी को बढ़ाता या घटाता है ropeJoint, जिससे रस्सी को लंबा या छोटा करने का प्रभाव पैदा होता है।

हम इस विधि को समाप्त करते हैं, इसके कॉल को अंत तक जोड़ते हैं Update():

 HandleRopeLength(); 

हमें झंडा स्थापित करने का एक तरीका भी चाहिए isColliding।

स्क्रिप्ट के निचले भाग में निम्नलिखित दो विधियाँ जोड़ें:

 void OnTriggerStay2D(Collider2D colliderStay) { isColliding = true; } private void OnTriggerExit2D(Collider2D colliderOnExit) { isColliding = false; } 

ये दो विधियाँ मोनोबेहौर लिपियों के आधार वर्ग की मूल विधियाँ हैं।

यदि कोलाइडर वर्तमान में खेल में किसी अन्य भौतिक वस्तु को छूता है, तो विधि लगातार आग OnTriggerStay2Dलगाएगा, ध्वज को एक isCollidingमान प्रदान करेगा true। इसका मतलब यह है कि जब स्लग पत्थर को छूता है, तो आइसोल्डिंग ध्वज को एक मान सौंपा जाता है true।

विधि को OnTriggerExit2Dट्रिगर किया जाता है जब एक कोलाइडर दूसरे कोलाइडर के क्षेत्र को छोड़ देता है, झंडे को झूठा स्थापित करता है।

ध्यान रखें: विधि OnTriggerStay2Dबहुत कम्प्यूटेशनल रूप से महंगी हो सकती है, इसलिए इसका उपयोग सावधानी से करें।

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

गेम को फिर से शुरू करें और इस बार रस्सी को ऊपर और नीचे ले जाने के लिए एरो कीज़ या डब्ल्यू / एस दबाएँ।


ट्यूटोरियल के इस भाग की तैयार परियोजना को यहाँ डाउनलोड किया जा सकता है ।

हम एक लंबा रास्ता तय कर चुके हैं - नॉन-स्विंगिंग स्लग-स्लग से लेकर एक्रोबैटिक शेल-फ्री गैस्ट्रोपॉड मोलस्क!

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


हालांकि, एक महत्वपूर्ण कार्य यहां गायब है - जब आवश्यक हो तो रस्सी "खोलना" नहीं कर सकती है। ट्यूटोरियल

के दूसरे भाग में हम इस समस्या को हल करेंगे।

लेकिन अगर आप एक मौका लेने के लिए तैयार हैं, तो इसे खुद करने की कोशिश क्यों न करें? आप इसके लिए एक शब्दकोश का उपयोग कर सकते हैं wrapPointsLookup।