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

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

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

काम पर लगना

यूनिटी में पहले भाग से तैयार परियोजना खोलें या ट्यूटोरियल के इस भाग के लिए ड्राफ्ट डाउनलोड करें, फिर 2DGrapplingHook-Part2-Starter खोलें। पहले भाग की तरह, हम एकता संस्करण 2017.1 या उच्चतर का उपयोग करेंगे।

परिदृश्य परियोजना फ़ोल्डर से संपादक में गेम दृश्य खोलें।


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

जब आप वापस लौटते हैं, तो आप देखेंगे कि पत्थर के बिंदु जिसके द्वारा रस्सी को घुमाया जाता था, वे फिर से नहीं खोलते हैं।


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

यदि स्लग, उसके सिर के ऊपर एक पत्थर से चिपकी हुई है, दाईं ओर झूलती है, तो रस्सी उस दहलीज के बाद झुक जाएगी जिस पर वह रिब के साथ 180 डिग्री के कोण बिंदु को पार करती है जिस पर स्लग वर्तमान में जुड़ा हुआ है। नीचे दिए गए आंकड़े में, यह एक हाइलाइट किए गए हरे बिंदु द्वारा दिखाया गया है।


जब स्लग वापस दूसरी दिशा में जाता है, तो रस्सी को उसी बिंदु पर फिर से अनहुक करना चाहिए (चित्र में लाल रंग में हाइलाइट किया गया):

असत्य का तर्क

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

यह कार्य थोड़ा डराने वाला लग सकता है। गणित सबसे बहादुर में भी डरावनी और निराशा को प्रेरित कर सकता है।

सौभाग्य से, एकता में कुछ महान गणित सहायक कार्य हैं जो हमारे जीवन को थोड़ा आसान बना सकते हैं।

आईडीई में रोपसिस्टम स्क्रिप्ट खोलें और एक नया तरीका बनाएं जिसका नाम है HandleRopeUnwrap() ।

 private void HandleRopeUnwrap() { } 

Update() जाएं Update() और हमारे नए तरीके पर कॉल समाप्त करें।

 HandleRopeUnwrap(); 

जबकि HandleRopeUnwrap() कुछ भी नहीं करता है, लेकिन अब हम किनारों से HandleRopeUnwrap() की पूरी प्रक्रिया से जुड़े तर्क को संसाधित कर सकते हैं।

जैसा कि आप ट्यूटोरियल के पहले भाग से याद करते हैं, हमने रोप रैपिंग पोजीशन को एक संग्रह में संग्रहित किया है जिसे ropePositions कहा जाता है, जो List<Vector2> संग्रह है। हर बार जब एक रस्सी एक किनारे के चारों ओर घूमती है, तो हम इस संग्रह में इस लपेट बिंदु की स्थिति को बनाए रखते हैं।

प्रक्रिया को और अधिक कुशल बनाने के लिए, हम HandleRopeUnwrap() में किसी भी तर्क को निष्पादित नहीं करेंगे यदि संग्रह में संग्रहीत पदों की संख्या 1 के बराबर या उससे कम है।

दूसरे शब्दों में, जब स्लग शुरुआती बिंदु पर झुका हुआ है और इसकी रस्सी अभी तक किनारों के चारों ओर लपेटी नहीं गई है, तो ropePositions वे की संख्या 1 होगी, और हम ropePositions प्रसंस्करण तर्क का पालन नहीं करेंगे।

मूल्यवान CPU चक्रों को सहेजने के लिए इस सरल return को HandleRopeUnwrap() के शीर्ष पर HandleRopeUnwrap() , क्योंकि यह विधि प्रति सेकंड कई बार Update() से कॉल की जाती है।

 if (ropePositions.Count <= 1) { return; } 

नई चर जोड़ना

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

 // Hinge =       // Anchor =     Hinge // Hinge Angle =   anchor  hinge // Player Angle =   anchor  player // 1 var anchorIndex = ropePositions.Count - 2; // 2 var hingeIndex = ropePositions.Count - 1; // 3 var anchorPosition = ropePositions[anchorIndex]; // 4 var hingePosition = ropePositions[hingeIndex]; // 5 var hingeDir = hingePosition - anchorPosition; // 6 var hingeAngle = Vector2.Angle(anchorPosition, hingeDir); // 7 var playerDir = playerPosition - anchorPosition; // 8 var playerAngle = Vector2.Angle(anchorPosition, playerDir); 

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

1. anchorIndex ropePositions संग्रह में सूचकांक है जो संग्रह के अंत से दो पदों पर है। हम इसे स्लग की स्थिति से रस्सी पर दो स्थिति में एक बिंदु के रूप में मान सकते हैं। नीचे दिए गए आंकड़े में, सतह से हुक के लगाव का यह पहला बिंदु है। ropePositions संग्रह ropePositions नए रैपिंग पॉइंट्स से भरते समय, यह पॉइंट हमेशा स्लग से दो पोज़िशन की दूरी पर रैपिंग पॉइंट बना रहेगा।
2. hingeIndex संग्रह का सूचकांक है जो वर्तमान काज के बिंदु को संग्रहीत करता है; दूसरे शब्दों में, जिस स्थिति में रस्सी वर्तमान में स्लग से रस्सी के अंत के करीब बिंदु के आसपास लपेट रही है। यह हमेशा स्लग से एक स्थान की दूरी पर होता है, यही कारण है कि हम ropePositions.Count - 1 उपयोग करते हैं।
3. anchorIndex गणना anchorIndex को ropePositions संग्रह में जगह anchorIndex किया जाता है और यह उस स्थिति का सरल वेक्टर 2 मान है।
4. hingePosition ropePositions संग्रह में hingeIndex के स्थान को संदर्भित करके गणना hingePosition जाती है और उस स्थिति का सरल वेक्टर 2 मान है।
5. hingeDir एक वेक्टर है जो hingePosition से hingePosition तक निर्देशित है। कोण प्राप्त करने के लिए इसका प्रयोग निम्न चर में किया जाता है।
6. hingeAngle - उपयोगी सहायक फ़ंक्शन Vector2.Angle() का उपयोग Vector2.Angle() बिंदु के बीच के कोण की गणना करने के लिए किया जाता है।
7. playerDir एक वेक्टर है जो playerDir से स्लग की वर्तमान स्थिति के लिए निर्देशित होता है (प्लेयरपोजिशन)
8. फिर, एंकर बिंदु और खिलाड़ी (स्लग) के बीच के कोण का उपयोग करके, playerAngle गणना playerAngle जाती है।

इन सभी चर की गणना ropePositions संग्रह में ropePositions मानों के रूप में संग्रहीत पदों का उपयोग करके की जाती है और इन पदों की तुलना अन्य पदों या खिलाड़ी की वर्तमान स्थिति (स्लग) के साथ की जाती है।

तुलना के लिए उपयोग किए जाने वाले दो महत्वपूर्ण चर hingeAngle और hingeAngle हैं।

hingeAngle में संग्रहीत मूल्य स्थिर रहना चाहिए क्योंकि यह हमेशा hingeAngle से रस्सी के दो "सिलवटों" के बिंदु के बीच एक निरंतर कोण होता है और वर्तमान "रस्सी के गुना" स्लग के सबसे करीब होता है जो रस्सी के अनचाहे या मोड़ने के बाद तक नहीं हिलता है एक नया मोड़ बिंदु जोड़ा जाएगा।

जब स्लग playerAngle बदल जाता है। इस कोण की तुलना hingeAngle , और यह भी hingeAngle कि क्या स्लग इस कोने के बाएँ या दाएँ है, हम यह निर्धारित कर सकते हैं कि स्लग के सबसे नज़दीकी मोड़ बिंदु को अलग किया जाना चाहिए या नहीं।

इस ट्यूटोरियल के पहले भाग में, हमने wrapPointsLookup पदों को wrapPointsLookup नामक शब्दकोश में wrapPointsLookup । हर बार जब हम मोड़ बिंदु को बचाते हैं, तो हमने इसे कुंजी के रूप में स्थिति के साथ शब्दकोश में जोड़ा और मान के रूप में 0 के साथ। हालांकि, 0 का यह मान बल्कि रहस्यमय था, है ना?

हम इस मान का उपयोग अपने कोण के सापेक्ष स्लग बिंदु की स्थिति (स्लैंग के सबसे नज़दीकी गुना बिंदु) के साथ करने के लिए करेंगे।

यदि आप -1 के मान को असाइन करते हैं, तो स्लग ( playerAngle ) का कोण हिंज ( hingeAngle ) के कोण से कम है, और 1 के मूल्य के साथ, hingeAngle का कोण hingeAngle से अधिक है।

इस तथ्य के कारण कि हम शब्दकोश में मूल्यों को सहेजते हैं, हर बार जब हम playerAngle तुलना hingeAngle , तो हम समझ सकते हैं कि क्या स्लग ने केवल सीमा पार कर ली है जिसके बाद रस्सी को अनहुक करना चाहिए।

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

रस्सी खोलना

नोट्स के साथ नीचे स्क्रीनशॉट पर एक नज़र डालें। हमारा स्लग चट्टान पर चढ़ गया, ऊपर की ओर एक रस्सी लपेटकर ऊपर की तरफ चट्टान के किनारे पर।


आप देख सकते हैं कि सबसे ऊपरी स्विंग स्थिति में, जहां स्लग अपारदर्शी है, इसके वर्तमान निकटतम गुना बिंदु (एक सफेद बिंदु के साथ चिह्नित) को 1 के मान के साथ wrapPointsLookup शब्दकोश में संग्रहीत किया जाएगा।

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

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

निम्नलिखित पंक्तियाँ डालकर एक नया UnwrapRopePosition(anchorIndex, hingeIndex) विधि UnwrapRopePosition(anchorIndex, hingeIndex) जोड़ें:

 private void UnwrapRopePosition(int anchorIndex, int hingeIndex) { } 

ऐसा करने के बाद, वापस HandleRopeUnwrap() । नए जोड़े गए चर के तहत, निम्न तर्क जोड़ें, जो दो मामलों को संभालेंगे: playerAngle hingeAngle तुलना में कम और playerAngle hingeAngle से अधिक hingeAngle :

 if (playerAngle < hingeAngle) { // 1 if (wrapPointsLookup[hingePosition] == 1) { UnwrapRopePosition(anchorIndex, hingeIndex); return; } // 2 wrapPointsLookup[hingePosition] = -1; } else { // 3 if (wrapPointsLookup[hingePosition] == -1) { UnwrapRopePosition(anchorIndex, hingeIndex); return; } // 4 wrapPointsLookup[hingePosition] = 1; } 

यह कोड पहले मामले के लिए ऊपर वर्णित तर्क के स्पष्टीकरण के अनुरूप होना चाहिए (जब hingeAngle < hingeAngle ), लेकिन दूसरे मामले को भी संभालता है (जब hingeAngle > hingeAngle )।

1. यदि स्लग के सबसे करीब का वर्तमान गुना बिंदु उस बिंदु पर 1 का मान hingeAngle जहां hingeAngle < hingeAngle , तो हम इस बिंदु को हटा देते हैं और वापसी करते हैं ताकि बाकी विधि निष्पादित न हो।
2. अन्यथा, यदि मोड़ बिंदु को अंतिम रूप से 1 के मान के साथ चिह्नित नहीं किया गया था, लेकिन hingeAngle से कम है, तो -1 को सौंपा गया है।
3. यदि स्लग के सबसे नज़दीकी मोड़ बिंदु -1 उस बिंदु पर है जहाँ hingeAngle > hingeAngle , तो बिंदु को हटा दें और वापस लौटें।
4. अन्यथा, हम हिंग की स्थिति में मोड़ बिंदुओं के शब्दकोश में प्रविष्टियों को 1 पर असाइन करते हैं।

यह कोड सुनिश्चित करता है कि wrapPointsLookup डिक्शनरी हमेशा अपडेट की जाती है, यह सुनिश्चित करते हुए कि वर्तमान बेंड पॉइंट (स्लग के सबसे करीब) का मान बेंड पॉइंट के सापेक्ष वर्तमान स्लग कोण से मेल खाता है।

यह मत भूलो कि मान -1 है जब स्लग कोण हिंज कोण (संदर्भ बिंदु के सापेक्ष) से ​​कम है, और 1 जब स्लग कोण काज कोण से बड़ा होता है।

अब हम RopeSystem स्क्रिप्ट में UnwrapRopePosition() को एक कोड के साथ UnwrapRopePosition() करेंगे जो सीधे अनप्लगिंग में संलग्न होगा, संदर्भ स्थिति को आगे बढ़ाएगा और रस्सी दूरी के मान को एक नया दूरी मान असाइन करेगा DistanceJoint2D। पहले बनाई गई विधि डिस्क में निम्नलिखित पंक्तियाँ जोड़ें:

  // 1 var newAnchorPosition = ropePositions[anchorIndex]; wrapPointsLookup.Remove(ropePositions[hingeIndex]); ropePositions.RemoveAt(hingeIndex); // 2 ropeHingeAnchorRb.transform.position = newAnchorPosition; distanceSet = false; // Set new rope distance joint distance for anchor position if not yet set. if (distanceSet) { return; } ropeJoint.distance = Vector2.Distance(transform.position, newAnchorPosition); distanceSet = true; 

1. वर्तमान एंकर पॉइंट का सूचकांक (स्लग से रस्सी की दूसरी स्थिति) काज की नई स्थिति बन जाती है, और काज की पुरानी स्थिति को हटा दिया जाता है (वह जो पहले स्लग के सबसे करीब था और जिसे अब हम "अप्राप्य" कहते हैं)। चर newAnchorPosition रस्सी पदों की सूची में मान anchorIndex असाइन किया गया है। इसके बाद एंकर पॉइंट की अद्यतन स्थिति को स्थिति के लिए उपयोग किया जाएगा।
2. रस्सी-संयुक्त RigidBody2D (जिस से DistanceJoint2D रस्सी जुड़ी हुई है) एंकर पॉइंट की नई स्थिति में अपनी स्थिति बदल देता है। यह दूरी पर स्लग की सुगम निरंतर गति सुनिश्चित करता है जब यह दूरीजॉइंट 2 डी से जुड़ा होता है, और यह कनेक्शन इसे नई स्थिति के सापेक्ष जारी रखने की अनुमति देता है, जो संदर्भ बन गया - दूसरे शब्दों में, अपनी स्थिति के नीचे रस्सी के अगले बिंदु के सापेक्ष।
3. तब आपको नए संदर्भ बिंदु पर स्लग से दूरी में तेज बदलाव को ध्यान में रखते हुए ,JJoint2D दूरी मान को अपडेट करने की आवश्यकता है। यदि यह पहले से नहीं किया गया है, तो distanceSet फ्लैग की एक त्वरित जांच की जाती है, और दूरी को स्लग और एंकर बिंदु की नई स्थिति के बीच की गणना की गई दूरी का मान सौंपा जाता है।

स्क्रिप्ट को सहेजें और संपादक पर वापस लौटें। खेल फिर से शुरू करें और देखें कि कैसे किनारों से रस्सी अलग हो जाती है जब स्लग प्रत्येक मोड़ बिंदु की दहलीज मूल्यों को पार करता है!


यद्यपि तर्क तैयार है, हम playerAngle को hingeAngle ( if (playerAngle < hingeAngle) ) के साथ तुलना करने से पहले HandleRopeUnwrap() कुछ सहायक कोड जोड़ देंगे।

 if (!wrapPointsLookup.ContainsKey(hingePosition)) { Debug.LogError("We were not tracking hingePosition (" + hingePosition + ") in the look up dictionary."); return; } 

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

इसके अलावा, इसके लिए धन्यवाद, हम इस तरह के सीमित मामलों को अधिक आसानी से संभाल लेंगे; इसके अलावा, हम इस घटना में अपना स्वयं का त्रुटि संदेश प्राप्त करते हैं कि कुछ अनावश्यक होता है।

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

यहाँ ट्यूटोरियल के इस दूसरे और अंतिम भाग की तैयार परियोजना का लिंक दिया गया है ।

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


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

• दो-स्टिक शूटर
• पहला व्यक्ति शूटर
• टॉवर रक्षा खेल (वीआर समर्थन के साथ!)
• 2 डी platformer

इस पुस्तक को पढ़ने के बाद, आप सीखेंगे कि विंडोज, मैकओएस, आईओएस और अन्य प्लेटफार्मों के लिए अपने खुद के गेम कैसे बनाएं!

यह पुस्तक शुरुआती और उन दोनों के लिए अभिप्रेत है जो अपने एकता कौशल को पेशेवर स्तर पर अपग्रेड करना चाहते हैं। पुस्तक को मास्टर करने के लिए आपको प्रोग्रामिंग अनुभव (किसी भी भाषा में) की आवश्यकता होती है।