👸🏼 🤹🏼 📐 सुपर मारियो ब्रदर्स क्लोन गेम लिखना (भाग 1) 🐬 👩🏿‍🤝‍👨🏾 📹

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

याकूब गुंडरसन द्वारा इस अद्भुत ट्यूटोरियल में , हम अपना खुद का प्लेटफ़ॉर्मर बनाएंगे; लेकिन चूंकि मुख्य पात्र कोअला होगा, इसलिए हम अपने खेल को "सुपर कोएलियो ब्रदर्स!" कहेंगे;]
इसके अलावा, यांत्रिकी को सरल बनाने के लिए, हम बढ़ते दुश्मनों के बारे में भूल जाते हैं। इसके बजाय, हम फर्श में एम्बेडेड जड़ी बूटियों का उपयोग करेंगे। यह हमें पूरी तरह से प्लेटफ़ॉर्मर के दिल - भौतिक इंजन पर ध्यान केंद्रित करने की अनुमति देगा।

चेतावनी! कट के तहत, अनूदित पाठ, चित्र, कोड (अनुवादित नहीं कोड) की एक अविश्वसनीय राशि और अपने स्वयं के भौतिक इंजन बनाने के लिए एक गाइड!

यह ट्यूटोरियल पहले से मानता है कि आप Cocos2D प्रोग्रामिंग की मूल बातें से परिचित हैं। अन्यथा, मैं दृढ़ता से अनुशंसा करता हूं कि आप पहले रे की वेबसाइट पर कुछ पाठों से परिचित हों।

चलिए शुरू करते हैं

आरंभ करने के लिए, इस ट्यूटोरियल के लिए स्टार्टर प्रोजेक्ट डाउनलोड करें। इसे अनज़िप करें, इसे एक्सकोड में खोलें, इसे चलाएं। एमुलेटर स्क्रीन पर कुछ इसी तरह दिखाई देना चाहिए:

यह सही है - सिर्फ एक उबाऊ खाली स्क्रीन! :] हम इसे पूरी तरह से भर देंगे क्योंकि हम ट्यूटोरियल के माध्यम से प्रगति करते हैं
सभी आवश्यक चित्र और ध्वनियाँ पहले ही स्टार्टर प्रोजेक्ट में जोड़ दी गई हैं। आइए परियोजना की सामग्री पर जाएं:

खेल कला। इसमें रे विकी की पत्नी से एक मुफ्त गेम आर्ट पैक शामिल है।
स्तर का नक्शा। मैंने विशेष रूप से आपके लिए एक स्तर का नक्शा तैयार किया है, जो एसएमबी में पहले स्तर से शुरू होता है।
महान ध्वनि प्रभाव। सब के बाद, raywenderlich.com के साथ एक ट्यूटोरियल! :]
उपवर्ग CCLayer। GameLevelLayer नामक एक वर्ग जो हमारे अधिकांश भौतिकी इंजन को लागू करता है। हालांकि अब यह कॉर्क की तरह खाली है। (हाँ, इस बच्चे को भरे जाने की प्रतीक्षा है!)
उपवर्ग CCSprite। प्लेयर नामक एक वर्ग जिसमें कोआला तर्क होता है। अभी, हमारी कोआला दूरी में उड़ने की कोशिश कर रही है!

भौतिक इंजन की मूल बातें

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

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

भौतिकी इंजन दो मुख्य कार्य करता है:

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

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

एक भौतिक इंजन बनाना

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

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

हम कार्यक्रम के हर चरण में इन चरणों से गुजरेंगे। हमारे खेल में, गुरुत्वाकर्षण लगातार कोआला को फर्श के माध्यम से नीचे और नीचे सिंक करने के लिए मजबूर करता है, लेकिन हर बार टकराव का पता लगाने से यह फर्श के ऊपर एक बिंदु पर वापस आ जाता है। आप इस सुविधा का उपयोग यह निर्धारित करने के लिए भी कर सकते हैं कि कोआला जमीन को छूता है या नहीं। यदि नहीं, तो आप खिलाड़ी को कूदने की स्थिति में कूदने से रोक सकते हैं या बस एक बाधा से कूद सकते हैं।
अंक 1-5 कोआला वस्तु के अंदर होते हैं। इस ऑब्जेक्ट के अंदर सभी आवश्यक जानकारी संग्रहीत की जानी चाहिए और कोएले को अपने चर को अपडेट करने की अनुमति देना काफी तर्कसंगत है।
हालांकि, जब यह 6 वें बिंदु पर आता है - टकरावों की परिभाषा - हमें स्तर की सभी विशेषताओं को ध्यान में रखना होगा, जैसे: दीवारें, फर्श, दुश्मन और अन्य खतरे। GameLevelLayer का उपयोग करके कार्यक्रम का हर चरण में टकराव का पता लगाया जाएगा - मैं आपको याद दिलाता हूं कि यह CCLayer का एक उपवर्ग है जो अधिकांश शारीरिक कार्य करेगा।
यदि हम कोआला को अपने हाथों से अपनी स्थिति को अपडेट करने की अनुमति देते हैं, तो अंत में कोआला दीवार या फर्श को छूएगा। और GameLevelLayer Koalu को वापस लाएगा। और इसलिए बार-बार - कि कोअला को ऐसा लगेगा जैसे वह कंप रहा है। (सुबह बहुत कॉफी, कोलियो?)
और इसलिए, हम कोएले को अपने राज्य को अपडेट करने की अनुमति नहीं देंगे। इसके बजाय, हम कोएले को एक नया वेरिएबल वांछितपोजिशन में जोड़ देंगे, जिसे कोआला अपडेट करेगा। GameLevelLayer जाँच करेगा कि क्या कोआला को वांछित स्थान पर ले जाया जा सकता है। यदि हां, तो GameLevelLayer कोअला की स्थिति को अपडेट करेगा।
क्या सब कुछ स्पष्ट है? आइए देखें कि यह कोड में कैसा दिखता है!

डाउनलोड TMXTiledMap

मैं मानता हूं कि आप परिचित हैं कि टाइल मैप्स जैसे नक्शे कैसे काम करते हैं। यदि नहीं, तो मैं आपको इस ट्यूटोरियल में उनके बारे में पढ़ने की सलाह देता हूँ।
के स्तर पर एक नजर डालते हैं। अपने टाइल किए गए मानचित्र संपादक को लॉन्च करें (डाउनलोड करें यदि आपने ऐसा पहले नहीं किया है) और अपने प्रोजेक्ट फ़ोल्डर से Level1.tmx खोलें। आप निम्नलिखित देखेंगे:

यदि आप साइडबार को देखते हैं, तो आप देखेंगे कि हमारी तीन अलग-अलग परतें हैं:

खतरों: इस परत में ऐसी चीजें शामिल हैं जिन्हें जीवित रहने के लिए कोआला से सावधान रहना चाहिए।
दीवारें: इस परत में कोशिकाएँ होती हैं जिनके माध्यम से कोआला पास नहीं हो सकता है। मूल रूप से ये फ्लोर सेल होते हैं।
पृष्ठभूमि: इस परत में केवल सौंदर्य संबंधी चीजें हैं जैसे कि बादल या पहाड़ियां।

यह कोड का समय है! GameLevelLayer.m खोलें और #import बाद निम्नलिखित जोड़ें, लेकिन @implementation से पहले:

 @interface GameLevelLayer() { CCTMXTiledMap *map; } @end

हमने अपने प्रधान वर्ग में जाली नक्शे के साथ काम करने के लिए CCTMXTiledMap वर्ग के स्थानीय चर मानचित्र को जोड़ा है।
इसके बाद हम लेयर इनिशियलाइज़ेशन के दौरान अपने लेयर पर मेष मैप को सही जगह पर रखेंगे। निम्नलिखित init विधि में जोड़ें :

 CCLayerColor *blueSky = [[CCLayerColor alloc] initWithColor:ccc4(100, 100, 250, 255)]; [self addChild:blueSky]; map = [[CCTMXTiledMap alloc] initWithTMXFile:@"level1.tmx"]; [self addChild:map];

सबसे पहले, हमने नीले आकाश के रंगों में एक पृष्ठभूमि (CCLayerColor) को जोड़ा। कोड की अगली दो पंक्तियाँ बस मानचित्र चर (CCTMXTiledMap) को लोड कर रही हैं और इसे परत में जोड़ रही हैं।

अगला, PlayerLevelLayer.m में हम Player.h आयात करते हैं:

 #import "Player.h"

GameLevelLayer.m में अभी भी , @ interface अनुभाग में निम्न स्थानीय चर जोड़ें:

 Player * player;

अगला, init विधि में निम्नलिखित कोड के साथ कोअला को स्तर में जोड़ें:

 player = [[Player alloc] initWithFile:@"koalio_stand.png"]; player.position = ccp(100, 50); [map addChild:player z:15];

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

एक खेल की तरह दिखता है, लेकिन कोलियो गुरुत्वाकर्षण की अनदेखी करता है! यह समय इसे स्वर्ग से पृथ्वी तक कम करने का है - भौतिकी इंजन का उपयोग करके:]

कोलियो ग्रेविटी सिचुएशन

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

भगवान को बजाओ

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

पृथ्वी के नियम: CGPoints और Forces

चलो निम्नलिखित अवधारणाओं को निरूपित करते हैं:

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

एक भौतिक सिमुलेशन में, किसी वस्तु पर लागू किया गया बल वस्तु को एक निश्चित गति तक गति देगा, और वस्तु उस गति से आगे बढ़ेगी जब तक कि वह मार्ग में किसी अन्य बल का सामना न कर दे। गति एक ऐसा मूल्य है जो एक फ्रेम से अगले तक नए सक्रिय बलों के रूप में बदलता है।
हम CGPoint संरचनाओं का उपयोग करके तीन चीजें प्रस्तुत करेंगे: गति, बल / त्वरण और स्थिति। CGPoint संरचनाओं का उपयोग करने के दो कारण हैं:

वे 2 डी हैं। गति, शक्ति / त्वरण और स्थिति एक 2D गेम के लिए सभी 2D मान हैं। आप कह सकते हैं कि गुरुत्वाकर्षण केवल एक दिशा में कार्य करता है, लेकिन क्या हो सकता है, खेल में एक बिंदु पर, हमें तुरंत गुरुत्वाकर्षण की दिशा बदलने की आवश्यकता है? सुपर मारियो गैलेक्सी के बारे में सोचो!
यह सुविधाजनक है। CGPoint का उपयोग करके, हम Cocos2D में निर्मित विभिन्न विशेषताओं का उपयोग कर सकते हैं। विशेष रूप से, हम ccpAdd (जोड़), ccpSub (घटाव) और ccpMult (प्रकार फ़्लोट के एक चर द्वारा गुणा) का उपयोग करेंगे। यह सब हमारे कोड को पढ़ने और डीबग करने में बहुत आसान बना देगा!

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

कृपया ध्यान दें: यदि उपरोक्त में से कोई भी भ्रामक है, तो एक अद्भुत व्यक्ति, डैनियल शिफमैन ने वैक्टर पर एक महान ट्यूटोरियल लिखा है, जो संरचनाओं के उपयोग पर बलों की क्रियाओं के बारे में पूरी तरह से बताता है।

चलो गुरुत्वाकर्षण के साथ शुरू करते हैं। हम एक रन लूप लिखेंगे जिसमें हम बलों का उपयोग करेंगे। निम्न शर्त को बंद करने से पहले GameLevelLayer.m फ़ाइल के init विधि में निम्न कोड जोड़ें:

 [self schedule:@selector(update:)];

अगला, वर्ग में एक नई विधि जोड़ें:

 - (void)update:(ccTime)dt { [player update:dt]; }

अगला, Player.h खोलें और इसे इस तरह से देखें:

 #import <Foundation/Foundation.h> #import "cocos2d.h" @interface Player : CCSprite @property (nonatomic, assign) CGPoint velocity; - (void)update:(ccTime)dt; @end

निम्न कोड को Player.m में जोड़ें:

मुझे क्लिक करें

 #import "Player.h" @implementation Player @synthesize velocity = _velocity; // 1 - (id)initWithFile:(NSString *)filename { if (self = [super initWithFile:filename]) { self.velocity = ccp(0.0, 0.0); } return self; } - (void)update:(ccTime)dt { // 2 CGPoint gravity = ccp(0.0, -450.0); // 3 CGPoint gravityStep = ccpMult(gravity, dt); // 4 self.velocity = ccpAdd(self.velocity, gravityStep); CGPoint stepVelocity = ccpMult(self.velocity, dt); // 5 self.position = ccpAdd(self.position, stepVelocity); } @end

चलिए स्टेप बाई स्टेप उपर दिए गए कोड से चलते हैं

यहां हमने ऑब्जेक्ट को इनिशियलाइज़ करने के लिए एक नया init मेथड जोड़ा और स्पीड वैरिएबल को शून्य पर सेट किया।
यहाँ हमने गुरुत्वाकर्षण सदिश का मान निर्दिष्ट किया है। हर सेकंड, हम कोआला 450 पिक्सल डाउन की गति को तेज करते हैं।
यहाँ हमने फ्रेम दर को संतुष्ट करने के लिए गुरुत्वाकर्षण वेक्टर के मूल्य को कम करने के लिए ccpMult का उपयोग किया। ccpMult को एक फ्लोट और CGPoint प्राप्त होता है और CGPoint लौटाता है।
यहां, जैसे ही हमने वर्तमान चरण के लिए गुरुत्वाकर्षण की गणना की, हम इसे वर्तमान गति में जोड़ते हैं।
अंत में, जब हमने एक कदम की गति की गणना की, तो हम कोअला की स्थिति को अद्यतन करने के लिए ccpAdd का उपयोग करते हैं।

बधाई! हम अपने पहले भौतिकी इंजन को बनाने के लिए सही रास्ते पर हैं! परिणाम देखने के लिए अपना प्रोजेक्ट चलाएं!

Oooo - कोलियो फर्श के माध्यम से गिरता है! चलो इसे ठीक करते हैं।

रात में किक - टक्कर का पता लगाना

टक्कर का पता लगाना किसी भी भौतिक इंजन की नींव है। 3 डी ऑब्जेक्ट्स के कॉम्प्लेक्स फ्रेम के सरल उपयोग से लेकर कई अलग-अलग प्रकार की टक्कर का पता लगाना है। सौभाग्य से हमारे लिए, प्लेटफ़ॉर्मर को जटिल संरचनाओं की आवश्यकता नहीं होती है।
वस्तुओं के साथ कोआला टकराव का पता लगाने के लिए, हम कोशिकाओं के लिए TMXTileMap का उपयोग करेंगे जो सीधे कोआला को घेरते हैं। इसके अलावा, आईओएस में निर्मित कई कार्यों का उपयोग करते हुए, हम यह जांचेंगे कि क्या कोआला का छिड़काव किसी सेल के स्प्राइट को काटता है या नहीं।
CGRectIntersectsRect और CGRectIntersection फ़ंक्शन इन चेकों को बहुत सरल बनाते हैं। CGRectIntersectsRect चेक करता है कि दो आयतें प्रतिच्छेद करती हैं, और CGRectIntersection प्रतिच्छेदन आयत लौटाता है।
सबसे पहले, हमें अपने कोअला के दायरे को परिभाषित करने की आवश्यकता है। प्रत्येक लोड किए गए स्प्राइट में एक फ्रेम होता है, जो बनावट का आकार होता है और जिसे बाउंडिंगबॉक्स नामक पैरामीटर का उपयोग करके एक्सेस किया जा सकता है।
अगर यह पहले से ही बाउंडिंगबॉक्स में है तो फ्रेम को क्यों परिभाषित करें? बनावट में आमतौर पर इसके चारों ओर पारदर्शी किनारे होते हैं, जिन्हें हम टकराव का निर्धारण करते समय ध्यान में नहीं रखना चाहते हैं।
कभी-कभी हमें स्प्राइट की वास्तविक छवि (पारदर्शी नहीं) के आसपास भी कुछ पिक्सेल पर विचार करने की आवश्यकता नहीं होती है। जब मारियो एक दीवार से टकराता है, तो क्या वह इसे थोड़ा छूता है, या उसकी नाक एक ब्लॉक में थोड़ी दफन है?
आइये इसे आजमाते हैं। Player.h में जोड़ें:

 -(CGRect)collisionBoundingBox;

और Player.m में जोड़ें:

 - (CGRect)collisionBoundingBox { return CGRectInset(self.boundingBox, 2, 0); }

CGRectInset दूसरे और तीसरे तर्क से पिक्सेल की संख्या से CGRect को संपीड़ित करता है। हमारे मामले में, हमारे टक्कर फ्रेम की चौड़ाई प्रत्येक तरफ छह पिक्सेल छोटे - तीन पिक्सेल होगी।

वजन उठाना

वजन उठाने का समय आ गया है। ("अरे, क्या आपने मुझे अभी वसा कहा है?" कोलियो कहते हैं)।
हम टकराव का पता लगाने के लिए हमारे GameLevelLayer में कई तरीकों की आवश्यकता होगी। विशेष रूप से:

एक विधि जो वर्तमान कोलियो सेल के आसपास के आठ कोशिकाओं के निर्देशांक को लौटाती है।
एक विधि जो यह निर्धारित करती है कि कौन सी कोशिका एक बाधा है (और सामान्य रूप से कोई भी हो)। कुछ कोशिकाओं में भौतिक गुण (बादल) नहीं होते हैं, और कोलियो उनसे नहीं टकराएगा।
एक विधि जो प्राथमिकता क्रम में टकरावों को संसाधित करती है।

हम दो सहायक कार्य बनाएंगे जो ऊपर वर्णित विधियों को सरल बनाते हैं।

एक विधि जो एक कोलियो सेल की स्थिति निर्धारित करती है।
एक विधि जो सेल निर्देशांक प्राप्त करती है और Cocos2D निर्देशांक में सेल की आयत लौटाती है।

GameLevelLayer.m के लिए निम्न कोड जोड़ें:

 - (CGPoint)tileCoordForPosition:(CGPoint)position { float x = floor(position.x / map.tileSize.width); float levelHeightInPixels = map.mapSize.height * map.tileSize.height; float y = floor((levelHeightInPixels - position.y) / map.tileSize.height); return ccp(x, y); } - (CGRect)tileRectFromTileCoords:(CGPoint)tileCoords { float levelHeightInPixels = map.mapSize.height * map.tileSize.height; CGPoint origin = ccp(tileCoords.x * map.tileSize.width, levelHeightInPixels - ((tileCoords.y + 1) * map.tileSize.height)); return CGRectMake(origin.x, origin.y, map.tileSize.width, map.tileSize.height); }

पहली विधि पिक्सेल में निर्देशांक में स्थित सेल के निर्देशांक को लौटाती है जिसे हम विधि में पास करते हैं। सेल की स्थिति प्राप्त करने के लिए, हम बस निर्देशांक को सेल आकार से विभाजित करते हैं।
हमें ऊंचाई के निर्देशांक को उलटने की जरूरत है, क्योंकि Cocos2D / OpenGL सिस्टम के निर्देशांक निचले बाएं कोने से शुरू होते हैं, और सिस्टम निर्देशांक ऊपरी बाएं कोने से शुरू होते हैं। मानक - यह अच्छा नहीं है?
दूसरी विधि इसके विपरीत करती है। यह कोशिका के आकार द्वारा कोशिका के गुणन को गुणा करता है और उस कोशिका के CGRect को लौटाता है। फिर से, हमें ऊंचाई का विस्तार करने की आवश्यकता है।
हमें ऊंचाई के y-निर्देशांक में एक को जोड़ने की आवश्यकता क्यों है? याद रखें, कोशिकाओं के निर्देशांक शून्य से शुरू होते हैं, इसलिए 20 कोशिकाओं में 19 का वास्तविक समन्वय होता है। यदि हम एक को ऊंचाई पर नहीं जोड़ते हैं, तो बिंदु 19 * टाइलहाइट होगा।

मैं कोशिकाओं से घिरा हुआ हूँ!

अब चलो उस विधि पर चलते हैं जो कोआला के आसपास की कोशिकाओं को निर्धारित करता है। इस पद्धति में, हम एक सरणी बनाएंगे, जिसे हम वापस करेंगे। इस सरणी में इस सेल के लिए सेल का GID, सेल निर्देशांक और CGRect जानकारी होगी।
हम इस सरणी को प्राथमिकता के क्रम में व्यवस्थित करेंगे, जिसमें हम टकरावों का निर्धारण करेंगे। उदाहरण के लिए, हम विकर्णों को परिभाषित करने से पहले, नीचे से, दाएं से, ऊपर से टकराव निर्धारित करना चाहते हैं। इसके अलावा, जब हम निचले सेल के साथ कोआला की टक्कर का पता लगाते हैं, तो हम जमीन को छूने के लिए झंडा लगाते हैं।
इस विधि को GameLevelLayer.m में जोड़ें:

मुझे क्लिक करें

 - (NSArray *)getSurroundingTilesAtPosition:(CGPoint)position forLayer:(CCTMXLayer *)layer { CGPoint plPos = [self tileCoordForPosition:position]; //1 NSMutableArray *gids = [NSMutableArray array]; //2 for (int i = 0; i < 9; i++) { //3 int c = i % 3; int r = (int)(i / 3); CGPoint tilePos = ccp(plPos.x + (c - 1), plPos.y + (r - 1)); int tgid = [layer tileGIDAt:tilePos]; //4 CGRect tileRect = [self tileRectFromTileCoords:tilePos]; //5 NSDictionary *tileDict = [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt:tgid], @"gid", [NSNumber numberWithFloat:tileRect.origin.x], @"x", [NSNumber numberWithFloat:tileRect.origin.y], @"y", [NSValue valueWithCGPoint:tilePos],@"tilePos", nil]; [gids addObject:tileDict]; } [gids removeObjectAtIndex:4]; [gids insertObject:[gids objectAtIndex:2] atIndex:6]; [gids removeObjectAtIndex:2]; [gids exchangeObjectAtIndex:4 withObjectAtIndex:6]; [gids exchangeObjectAtIndex:0 withObjectAtIndex:4]; //6 for (NSDictionary *d in gids) { NSLog(@"%@", d); } //7 return (NSArray *)gids; }

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

कोअला और खतरों। यदि कोई झड़प होती है, तो हम कोआला को मारते हैं (क्रूर, सही?)।
कोआला और दीवारें। यदि टक्कर होती है, तो हम कोएले को इस दिशा में आगे बढ़ने की अनुमति नहीं देंगे। "रुको, घोड़ी!"
कोआला और पृष्ठभूमि। अगर टक्कर होती है, तो हम कुछ नहीं करते हैं। आलसी प्रोग्रामर सबसे अच्छा प्रोग्रामर है। अच्छा, या लोग क्या कहते हैं?

बेशक, विभिन्न ब्लॉकों के साथ विभिन्न टकरावों को निर्धारित करने के लिए कई तरीके हैं, लेकिन हमारे पास क्या है - नक्शे पर परतें, काफी प्रभावी हैं।
ठीक है, चलो चरण दर चरण कोड के माध्यम से चलते हैं।

1. सबसे पहले, हम सेल के निर्देशांक में प्रवेश करते हैं (जो कोअला के निर्देशांक होंगे)।
2. अगला, हम एक नया ऐरे बनाते हैं जो सेल के बारे में जानकारी लौटाएगा।
3. अगला, हम 9 बार चक्र शुरू करते हैं - चूंकि हमारे पास 9 संभावित आंदोलन कोशिकाएं हैं, जिसमें सेल शामिल है जिसमें कोआला पहले से ही स्थित है। अगली कुछ पंक्तियाँ नौ कोशिकाओं की स्थिति को परिभाषित करती हैं और उन्हें टाइलपोस चर से संग्रहीत करती हैं।

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

4. चौथे खंड में, हम टाइलगाइड कहते हैं:। यह विधि सेल के GID को एक विशिष्ट समन्वय पर लौटाती है। यदि प्राप्त निर्देशांक पर कोई सेल नहीं है, तो विधि शून्य हो जाती है। इसके बाद, हम शून्य का उपयोग "सेल न पाए गए" मूल्य में करेंगे।
5. अगला, हम Cocos2D डेटा समन्वय पर सेल के लिए CGRect की गणना करने के लिए एक सहायक विधि का उपयोग करते हैं। हम प्राप्त सूचना को NS सहारे में संग्रहीत करते हैं। विधि प्राप्त NSDictionary से एक सरणी देता है।
6. छठे खंड में, हम कोआला सेल को सरणी से हटाते हैं और कोशिकाओं को प्राथमिकता क्रम में क्रमबद्ध करते हैं।

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

7. धारा सात में चक्र हमें वास्तविक समय में कोशिकाओं की निगरानी करने की अनुमति देता है। इसलिए, हम यह जान सकते हैं कि सब कुछ योजना के अनुसार हो रहा है।

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

GameLevelLayer.m के अंदर , निम्नलिखित परिवर्तन करें:

 //   @interface CCTMXLayer *walls; //    init,  ,      walls = [map layerNamed:@"walls"]; //    update [self getSurroundingTilesAtPosition:player.position forLayer:walls];

भागो! लेकिन, दुर्भाग्य से, खेल क्रैश हो जाता है। हम कंसोल में निम्नलिखित देखते हैं:

सबसे पहले, हम सेल पोजीशन और GID मानों के बारे में जानकारी प्राप्त करते हैं (हालाँकि अधिकतर शून्य हैं, क्योंकि शीर्ष पर खाली इलाक़ा है)।
अंत में, "TMXLayer: अमान्य स्थिति" त्रुटि के साथ सब कुछ क्रैश हो जाता है। यह तब होता है जब मानचित्र के किनारों के बाहर की स्थिति टाइलगेटैट: विधि से पारित हो जाती है।
हम थोड़ी देर बाद इस त्रुटि से बचेंगे - लेकिन पहले, हम टकराव की मौजूदा परिभाषा को बदलने जा रहे हैं।

हम कोआला के विशेषाधिकारों को वापस लेते हैं

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

अगर कोआला स्वतंत्र रूप से अपनी स्थिति को अपडेट करेगा, तो अंत में वह पागल की तरह कूदना शुरू कर देगा! लेकिन हम यह नहीं चाहते हैं, नहीं?
तो कोआला को एक अतिरिक्त चर, वांछितपुनिशन की आवश्यकता होती है, जिसके साथ वह GameLevelLayer के साथ बातचीत करेगा।
हम चाहते हैं कि कोआला वर्ग स्वतंत्र रूप से अपनी अगली स्थिति की गणना करे। लेकिन GameLevelLayer को अपनी वैधता की जाँच के बाद ही कोआला को वांछित स्थिति में ले जाना चाहिए। यही बात टकराव का पता लगाने के चक्र पर भी लागू होती है - हम टकराव से पहले सभी कोशिकाओं की जाँच करने से पहले असली स्प्राइट को अपडेट नहीं करना चाहते हैं।
हमें कुछ चीजों को बदलने की जरूरत है। सबसे पहले, Player.h में निम्न जोड़ें

 @property (nonatomic, assign) CGPoint desiredPosition;

और Player.m में जोड़ा गया था जो संश्लेषित:

 @synthesize desiredPosition = _desiredPosition;

अब, Player.m में collisionBoundingBox विधि को बदलें ताकि यह इस तरह दिखे :

 - (CGRect)collisionBoundingBox { CGRect collisionBox = CGRectInset(self.boundingBox, 3, 0); CGPoint diff = ccpSub(self.desiredPosition, self.position); CGRect returnBoundingBox = CGRectOffset(collisionBox, diff.x, diff.y); return returnBoundingBox; }

कोड का यह टुकड़ा वांछित स्थिति के आधार पर फ्रेम की गणना करता है जो गेमलेवलेयर टकरावों को निर्धारित करने के लिए उपयोग करेगा।

नोट: टक्कर फ्रेम की गणना करने के कई अलग-अलग तरीके हैं। आप CCNode कक्षा में पहले से मौजूद कोड के समान कोड लिख सकते हैं, लेकिन हमारी वर्तमान पद्धति कुछ स्पष्टता के बावजूद बहुत सरल है।

इसके बाद, अपडेट विधि में निम्नलिखित बदलाव करें ताकि यह वर्तमान स्थिति के बजाय वांछित स्थिति को अपडेट करे:

 //  'self.position = ccpAdd(self.position, stepVelocity);' : self.desiredPosition = ccpAdd(self.position, stepVelocity);

चलो टक्करों पर शुरू करें!

गंभीर उपलब्धियों के लिए समय आ गया है। हम यह सब एक साथ करने जा रहे हैं। GameLevelLayer.m के लिए निम्न विधि जोड़ें:

मुझे क्लिक करें

 - (void)checkForAndResolveCollisions:(Player *)p { NSArray *tiles = [self getSurroundingTilesAtPosition:p.position forLayer:walls ]; //1 for (NSDictionary *dic in tiles) { CGRect pRect = [p collisionBoundingBox]; //2 int gid = [[dic objectForKey:@"gid"] intValue]; //3 if (gid) { CGRect tileRect = CGRectMake([[dic objectForKey:@"x"] floatValue], [[dic objectForKey:@"y"] floatValue], map.tileSize.width, map.tileSize.height); //4 if (CGRectIntersectsRect(pRect, tileRect)) { CGRect intersection = CGRectIntersection(pRect, tileRect); //5 int tileIndx = [tiles indexOfObject:dic]; //6 if (tileIndx == 0) { //    p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y + intersection.size.height); } else if (tileIndx == 1) { //    p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y - intersection.size.height); } else if (tileIndx == 2) { //    p.desiredPosition = ccp(p.desiredPosition.x + intersection.size.width, p.desiredPosition.y); } else if (tileIndx == 3) { //    p.desiredPosition = ccp(p.desiredPosition.x - intersection.size.width, p.desiredPosition.y); } else { if (intersection.size.width > intersection.size.height) { //7 // ,     float intersectionHeight; if (tileIndx > 5) { intersectionHeight = intersection.size.height; } else { intersectionHeight = -intersection.size.height; } p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y + intersection.size.height ); } else { // ,     float resolutionWidth; if (tileIndx == 6 || tileIndx == 4) { resolutionWidth = intersection.size.width; } else { resolutionWidth = -intersection.size.width; } p.desiredPosition = ccp(p.desiredPosition.x , p.desiredPosition.y + resolutionWidth); } } } } } p.position = p.desiredPosition; //7 }

बहुत बढ़िया!आइए उस कोड को देखें जो हमने अभी लिखा था।

1. सबसे पहले हमें कोआला के आसपास कोशिकाओं का एक समूह मिलता है। अगला, हम इस सेट में प्रत्येक सेल के माध्यम से चक्र करते हैं। हर बार जब हम सेल से गुजरते हैं, तो हम इसे टकराव के लिए जाँचते हैं। यदि टक्कर होती है, तो हम कोआला के लिए वांछित प्रस्ताव को बदलते हैं।
2. लूप के प्रत्येक लूप के अंदर, हम पहले कोआला फ्रेम प्राप्त करते हैं। जब भी टकराव का पता चलता है, वांछित वांछित चर उस बिंदु पर अपना मान बदल देता है जहाँ टक्कर अब नहीं होती है।
3. अगला कदम यह है कि हम उस जीआईडी को प्राप्त करें जिसे हमने NS सहारे में संग्रहीत किया है, जो शून्य हो सकता है। यदि जीआईडी शून्य है, तो वर्तमान लूप समाप्त हो जाता है और हम अगले सेल पर जाते हैं।
4।यदि सेल नई स्थिति में है, तो हमें उसका CGRect प्राप्त करना होगा। इसमें टकराव हो भी सकता है और नहीं भी। हम इस प्रक्रिया को कोड की निम्नलिखित पंक्ति के साथ करते हैं और इसे टाइलरैक्ट वैरिएबल में सहेजते हैं। अब जब हमारे पास CGRect Koalas और cells हैं, तो हम टकराव की जाँच कर सकते हैं।
5. टक्करों के लिए कोशिकाओं की जांच करने के लिए, हम CGRectIntersectsRect चलाते हैं। यदि कोई टक्कर होती है, तो हमें CGRectIntersection () फ़ंक्शन का उपयोग करके CGRect चौराहे का वर्णन करने वाला CGRect मिलता है।

हमें दुविधा पर ध्यान दें ...

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

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

तो, हमें यह तय करने की आवश्यकता है कि लंबवत रूप से टकरावों के साथ कब काम करना है, और क्षैतिज रूप से, और दोनों क्रियाओं को परस्पर अनन्य रूप से संभालें। कुछ भौतिक इंजन लगातार पहली घटना को पहले संसाधित करते हैं, और फिर दूसरे को; लेकिन हम कोआला के सेल की स्थिति के आधार पर एक बेहतर निर्णय लेना चाहते हैं। इसलिए, उदाहरण के लिए, जब सेल कोआला से नीचे है, तो हम चाहते हैं कि टकराव पहचानकर्ता कोअला को वापस लौटाए।
लेकिन क्या होगा अगर सेल कोआला की स्थिति के लिए विकर्ण है? इस मामले में, हम CGRect चौराहों का उपयोग यह समझने के लिए करते हैं कि हमें कोआला को कैसे स्थानांतरित करना चाहिए। यदि इस आयत की चौड़ाई ऊंचाई से अधिक है, तो आपको कोआला को लंबवत रूप से वापस करने की आवश्यकता है। यदि ऊंचाई चौड़ाई से अधिक है, तो कोआला क्षैतिज रूप से आगे बढ़ना चाहिए।

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

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

कोड पर वापस!

चलो राक्षसी विधि पर वापस जाएं checkForAndResolveCollisions: ...

6. छठा खंड हमें वर्तमान सेल का सूचकांक प्राप्त करने की अनुमति देता है। हम सेल की स्थिति प्राप्त करने के लिए सेल इंडेक्स का उपयोग करते हैं। हम व्यक्तिगत रूप से आसन्न कोशिकाओं पर काम करने जा रहे हैं, कोअला को शिफ्ट करना, टकराव की लंबाई या ऊंचाई जोड़ना या घटाना। बहुत ही सरल।हालांकि, जैसे ही यह विकर्ण कोशिकाओं की बात आती है, हम पिछले अनुभाग में वर्णित एल्गोरिथ्म को लागू करने जा रहे हैं।
7. सातवें खंड में, हम निर्धारित करते हैं कि हमारा टकराव क्षेत्र चौड़ा है या लम्बा है? यदि चौड़ा - हम लंबवत काम करते हैं। यदि सेल इंडेक्स 5 से अधिक है, तो कोआला को ऊपर ले जाएं। यदि इस क्षेत्र को ऊपर की ओर बढ़ाया जाता है, तो हम क्षैतिज रूप से काम करते हैं। हम सेल इंडेक्स के आदेश के लिए एक समान सिद्धांत पर कार्य करते हैं। अंत में, हम Koale को प्राप्त स्थिति को असाइन करते हैं।

यह विधि हमारे टकराव का पता लगाने वाली प्रणाली का मस्तिष्क है।

आइए व्यवहार में सभी उपलब्ध ज्ञान का उपयोग करें! की विधि बदलें अद्यतन (अब भी में GameLevelLayer: )

 //  "[self getSurroundingTilesAtPosition:player.position forLayer:walls];" : [self checkForAndResolveCollisions:player];

आप GetSurroundingTilesAtPosition को निकाल या टिप्पणी भी कर सकते हैं : forLayer block:

  /* for (NSDictionary *d in gids) { NSLog(@"%@", d); } //8 */

भागो!परिणाम से आश्चर्यचकित?

पॉल कोलियो को रोकता है, लेकिन वह तुरंत उसमें डूब जाता है! क्यों?
क्या आप अनुमान लगा सकते हैं कि हम क्या चूक गए? याद रखें - खेल के हर चरण में हम कोआला की गति में गुरुत्वाकर्षण जोड़ते हैं। इसका मतलब है कि कोआला लगातार तेज हो रहा है।
हम लगातार कोआला के प्रक्षेपवक्र में गति को जोड़ते हैं जब तक कि यह एक सेल का आकार नहीं बन जाता है - हम एक चरण में पूरे सेल के माध्यम से आगे बढ़ते हैं, जो समस्याओं का कारण बनता है (याद रखें, हमने हाल ही में इस बारे में बात की थी)।
जैसे ही हम एक टकराव का पता लगाते हैं, हमें हमारे द्वारा सामना की गई सेल की दिशा में कोआला की गति को शून्य करने की आवश्यकता है! कोआला ने चलना बंद कर दिया है, इसलिए गति को फिर से समझना चाहिए।
यदि हम ऐसा नहीं करते हैं, तो हमारे पास अजीब खेल व्यवहार होगा। जैसा कि हमने पहले उल्लेख किया है, हमें यह निर्धारित करने के लिए एक तरीका चाहिए कि क्या कोआला जमीन को छू रहा है ताकि कोआला ऊंची कूद न कर सके। हम अब इस बॉक्स की जाँच करेंगे। CheckForAndResolveCollisions के लिए निम्न पंक्तियाँ जोड़ें :

मुझे क्लिक करें

 - (void)checkForAndResolveCollisions:(Player *)p { NSArray *tiles = [self getSurroundingTilesAtPosition:p.position forLayer:walls ]; //1 p.onGround = NO; ////// for (NSDictionary *dic in tiles) { CGRect pRect = [p collisionBoundingBox]; //3 int gid = [[dic objectForKey:@"gid"] intValue]; //4 if (gid) { CGRect tileRect = CGRectMake([[dic objectForKey:@"x"] floatValue], [[dic objectForKey:@"y"] floatValue], map.tileSize.width, map.tileSize.height); //5 if (CGRectIntersectsRect(pRect, tileRect)) { CGRect intersection = CGRectIntersection(pRect, tileRect); int tileIndx = [tiles indexOfObject:dic]; if (tileIndx == 0) { //   p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y + intersection.size.height); p.velocity = ccp(p.velocity.x, 0.0); ////// p.onGround = YES; ////// } else if (tileIndx == 1) { //   p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y - intersection.size.height); p.velocity = ccp(p.velocity.x, 0.0); ////// } else if (tileIndx == 2) { //  p.desiredPosition = ccp(p.desiredPosition.x + intersection.size.width, p.desiredPosition.y); } else if (tileIndx == 3) { //  p.desiredPosition = ccp(p.desiredPosition.x - intersection.size.width, p.desiredPosition.y); } else { if (intersection.size.width > intersection.size.height) { //tile is diagonal, but resolving collision vertially p.velocity = ccp(p.velocity.x, 0.0); ////// float resolutionHeight; if (tileIndx > 5) { resolutionHeight = intersection.size.height; p.onGround = YES; ////// } else { resolutionHeight = -intersection.size.height; } p.desiredPosition = ccp(p.desiredPosition.x, p.desiredPosition.y + resolutionHeight); } else { float resolutionWidth; if (tileIndx == 6 || tileIndx == 4) { resolutionWidth = intersection.size.width; } else { resolutionWidth = -intersection.size.width; } p.desiredPosition = ccp(p.desiredPosition.x + resolutionWidth, p.desiredPosition.y); } } } } } p.position = p.desiredPosition; //8 }

हर बार कोअला (आसन्न या विकर्ण) के तहत एक सेल होता है, हम p.onGround वैरिएबल का मान YES पर सेट करते हैं और गति को शून्य करते हैं। इसके अलावा, अगर कोआला के तहत एक आसन्न सेल है, तो हम इसकी गति को रीसेट करते हैं। यह हमें कोआला की वर्तमान गति पर सही ढंग से प्रतिक्रिया करने की अनुमति देगा।
हम लूप की शुरुआत में NO को onGround वेरिएबल सेट करते हैं। इस मामले में, onGround में केवल YES होगा, जब हम इसके नीचे सेल के साथ कोआला की टक्कर का पता लगाते हैं। हम इस सुविधा का उपयोग यह निर्धारित करने के लिए कर सकते हैं कि कोआला वर्तमान समय में कूद सकता है या नहीं।
zagalovochny फ़ाइल में निम्न कोड (और आप कार्यकारी में जरूरत है तो synthesize सब कुछ) में जोड़े Player.h :

 @property (nonatomic, assign) BOOL onGround;

और प्लेयर दोपहर में :

 @synthesize onGround = _onGround;

भागो! क्या सब कुछ इरादा के अनुसार काम करता है? हाँ! , ! हुर्रे!

आगे क्या है?

बधाई! ! , . — .
.
. .
, :
The Sonic the Hedgehog Wiki — , Sonic .
, हायर-ऑर्डर फन प्लेटफ़ॉर्मिंग गाइड ।

अनुवादक का नोट

मैंने इस लेख से प्रेरित होकर इस ट्यूटोरियल का अनुवाद करने का निर्णय लिया ।
मैं खुद वर्तमान में iOS पर एक प्लेटफॉर्म गेम लिख रहा हूं और सक्रिय रूप से raywenderlich.com पर ट्यूटोरियल का उपयोग कर रहा हूं । मैं सभी को सलाह देता हूं!
पहले भाग का अनुवाद करने में काफी समय लगने के बाद, मैंने दूसरे भाग के अनुवाद के बारे में सोचा। यदि आवश्यक हो तो टिप्पणियों में लिखें। यदि यह मांग में है, तो मैं अनुवाद करूंगा।
पाए गए सभी अशुद्धियों और टाइपो के बारे में, कृपया इब्राहीम या यहाँ टिप्पणियों में लिखें।
मुझे ट्यूटोरियल के बारे में सभी सवालों के जवाब देने में खुशी होगी!

सुपर मारियो ब्रदर्स क्लोन गेम लिखना (भाग 1)

चलिए शुरू करते हैं

भौतिक इंजन की मूल बातें

एक भौतिक इंजन बनाना

डाउनलोड TMXTiledMap

कोलियो ग्रेविटी सिचुएशन

भगवान को बजाओ

पृथ्वी के नियम: CGPoints और Forces

रात में किक - टक्कर का पता लगाना

वजन उठाना

मैं कोशिकाओं से घिरा हुआ हूँ!

हम कोआला के विशेषाधिकारों को वापस लेते हैं

चलो टक्करों पर शुरू करें!

हमें दुविधा पर ध्यान दें ...

कोड पर वापस!

आगे क्या है?

अनुवादक का नोट

More articles: